backport/2412: network: Make litep2p the default backend in Kusama (#7866) (#7887)

Backport for:
- #7866


cc @EgorPopelyaev 🙏

Signed-off-by: Alexandru Vasile <[email protected]>
Co-authored-by: Bastian Köcher <[email protected]>

Author: lexnv

Cargo.lock

@@ -846,7 +846,7 @@ linked-hash-map = { version = "0.5.4" }
 linked_hash_set = { version = "0.1.4" }
 linregress = { version = "0.5.1" }
 lite-json = { version = "0.2.0", default-features = false }
-litep2p = { version = "0.9.1", features = ["websocket"] }
+litep2p = { version = "0.9.3", features = ["websocket"] }
 log = { version = "0.4.22", default-features = false }
 macro_magic = { version = "0.5.1" }
 maplit = { version = "1.0.2" }

Cargo.toml

@@ -30,7 +30,7 @@ use polkadot_node_network_protocol::{
 use polkadot_core_primitives::{Block as RelayBlock, Hash as RelayHash};
 use polkadot_node_subsystem_util::metrics::prometheus::Registry;
 use polkadot_primitives::CollatorPair;
-use polkadot_service::{overseer::OverseerGenArgs, IsParachainNode};
+use polkadot_service::{overseer::OverseerGenArgs, IdentifyNetworkBackend, IsParachainNode};
 
 use sc_authority_discovery::Service as AuthorityDiscoveryService;
 use sc_network::{
@@ -97,7 +97,12 @@ async fn build_interface(
 ) -> RelayChainResult<(Arc<(dyn RelayChainInterface + 'static)>, Option<CollatorPair>)> {
 	let collator_pair = CollatorPair::generate().0;
 	let blockchain_rpc_client = Arc::new(BlockChainRpcClient::new(client.clone()));
-	let collator_node = match polkadot_config.network.network_backend {
+
+	// If the network backend is unspecified, use the default for the given chain.
+	let default_backend = polkadot_config.chain_spec.network_backend();
+	let network_backend = polkadot_config.network.network_backend.unwrap_or(default_backend);
+
+	let collator_node = match network_backend {
 		sc_network::config::NetworkBackendType::Libp2p =>
 			new_minimal_relay_chain::<RelayBlock, sc_network::NetworkWorker<RelayBlock, RelayHash>>(
 				polkadot_config,

cumulus/client/relay-chain-minimal-node/src/lib.rs

@@ -102,6 +102,7 @@ substrate-state-trie-migration-rpc.workspace = true
 substrate-state-trie-migration-rpc.default-features = true
 polkadot-cli.workspace = true
 polkadot-cli.default-features = true
+polkadot-cli.features = ["service"]
 polkadot-primitives.workspace = true
 polkadot-primitives.default-features = true
 cumulus-client-cli.workspace = true

cumulus/polkadot-omni-node/lib/Cargo.toml

@@ -31,6 +31,7 @@ use cumulus_client_service::{
 use cumulus_primitives_core::{BlockT, ParaId};
 use cumulus_relay_chain_interface::{OverseerHandle, RelayChainInterface};
 use parachains_common::Hash;
+use polkadot_cli::service::IdentifyNetworkBackend;
 use polkadot_primitives::CollatorPair;
 use prometheus_endpoint::Registry;
 use sc_consensus::DefaultImportQueue;
@@ -383,7 +384,10 @@ where
 		hwbench: Option<HwBench>,
 		node_extra_args: NodeExtraArgs,
 	) -> Pin<Box<dyn Future<Output = sc_service::error::Result<TaskManager>>>> {
-		match parachain_config.network.network_backend {
+		// If the network backend is unspecified, use the default for the given chain.
+		let default_backend = parachain_config.chain_spec.network_backend();
+		let network_backend = parachain_config.network.network_backend.unwrap_or(default_backend);
+		match network_backend {
 			sc_network::config::NetworkBackendType::Libp2p =>
 				<Self as NodeSpec>::start_node::<sc_network::NetworkWorker<_, _>>(
 					parachain_config,

cumulus/polkadot-omni-node/lib/src/common/spec.rs

@@ -20,6 +20,7 @@ mod manual_seal;
 use crate::common::spec::{DynNodeSpec, NodeSpec as NodeSpecT};
 use cumulus_primitives_core::ParaId;
 use manual_seal::ManualSealNode;
+use polkadot_cli::service::IdentifyNetworkBackend;
 use sc_service::{Configuration, TaskManager};
 
 /// The current node version for cumulus official binaries, which takes the basic
@@ -52,7 +53,11 @@ where
 		block_time: u64,
 	) -> sc_service::error::Result<TaskManager> {
 		let node = ManualSealNode::<T>::new();
-		match config.network.network_backend {
+
+		// If the network backend is unspecified, use the default for the given chain.
+		let default_backend = config.chain_spec.network_backend();
+		let network_backend = config.network.network_backend.unwrap_or(default_backend);
+		match network_backend {
 			sc_network::config::NetworkBackendType::Libp2p =>
 				node.start_node::<sc_network::NetworkWorker<_, _>>(config, para_id, block_time),
 			sc_network::config::NetworkBackendType::Litep2p =>

cumulus/polkadot-omni-node/lib/src/nodes/mod.rs

@@ -69,7 +69,7 @@ use frame_system_rpc_runtime_api::AccountNonceApi;
 use polkadot_node_subsystem::{errors::RecoveryError, messages::AvailabilityRecoveryMessage};
 use polkadot_overseer::Handle as OverseerHandle;
 use polkadot_primitives::{CandidateHash, CollatorPair, Hash as PHash, PersistedValidationData};
-use polkadot_service::ProvideRuntimeApi;
+use polkadot_service::{IdentifyNetworkBackend, ProvideRuntimeApi};
 use sc_consensus::ImportQueue;
 use sc_network::{
 	config::{FullNetworkConfiguration, TransportConfig},
@@ -761,8 +761,12 @@ impl TestNodeBuilder {
 			format!("{} (relay chain)", relay_chain_config.network.node_name);
 
 		let multiaddr = parachain_config.network.listen_addresses[0].clone();
+
+		// If the network backend is unspecified, use the default for the given chain.
+		let default_backend = relay_chain_config.chain_spec.network_backend();
+		let network_backend = relay_chain_config.network.network_backend.unwrap_or(default_backend);
 		let (task_manager, client, network, rpc_handlers, transaction_pool, backend) =
-			match relay_chain_config.network.network_backend {
+			match network_backend {
 				sc_network::config::NetworkBackendType::Libp2p =>
 					start_node_impl::<_, sc_network::NetworkWorker<_, _>>(
 						parachain_config,

cumulus/test/service/src/lib.rs

@@ -21,6 +21,7 @@ use std::sync::Arc;
 use cli::{RelayChainCli, Subcommand, TestCollatorCli};
 use cumulus_primitives_core::relay_chain::CollatorPair;
 use cumulus_test_service::{chain_spec, new_partial, AnnounceBlockFn};
+use polkadot_service::IdentifyNetworkBackend;
 use sc_cli::{CliConfiguration, SubstrateCli};
 use sp_core::Pair;
 
@@ -103,9 +104,13 @@ fn main() -> Result<(), sc_cli::Error> {
 				})
 				.unwrap_or(cumulus_test_service::Consensus::Aura);
 
+			// If the network backend is unspecified, use the default for the given chain.
+			let default_backend = relay_chain_config.chain_spec.network_backend();
+			let network_backend =
+				relay_chain_config.network.network_backend.unwrap_or(default_backend);
 			let (mut task_manager, _, _, _, _, _) = tokio_runtime
 				.block_on(async move {
-					match relay_chain_config.network.network_backend {
+					match network_backend {
 						sc_network::config::NetworkBackendType::Libp2p =>
 							cumulus_test_service::start_node_impl::<
 								_,

cumulus/test/service/src/main.rs

@@ -327,6 +327,23 @@ impl IdentifyVariant for Box<dyn ChainSpec> {
 	}
 }
 
+/// A trait to identify the network backend based on the chain spec.
+pub trait IdentifyNetworkBackend {
+	/// Returns the default network backend.
+	fn network_backend(&self) -> sc_network::config::NetworkBackendType;
+}
+
+impl IdentifyNetworkBackend for Box<dyn ChainSpec> {
+	fn network_backend(&self) -> sc_network::config::NetworkBackendType {
+		// By default litep2p is enabled only on Kusama.
+		if self.is_kusama() {
+			sc_network::config::NetworkBackendType::Litep2p
+		} else {
+			sc_network::config::NetworkBackendType::Libp2p
+		}
+	}
+}
+
 #[cfg(feature = "full-node")]
 pub fn open_database(db_source: &DatabaseSource) -> Result<Arc<dyn Database>, Error> {
 	let parachains_db = match db_source {
@@ -1439,7 +1456,11 @@ pub fn build_full<OverseerGenerator: OverseerGen>(
 			capacity
 		});
 
-	match config.network.network_backend {
+	// If the network backend is unspecified, use the default for the given chain.
+	let default_backend = config.chain_spec.network_backend();
+	let network_backend = config.network.network_backend.unwrap_or(default_backend);
+
+	match network_backend {
 		sc_network::config::NetworkBackendType::Libp2p =>
 			new_full::<_, sc_network::NetworkWorker<Block, Hash>>(config, params),
 		sc_network::config::NetworkBackendType::Litep2p =>

polkadot/node/service/src/lib.rs

@@ -29,7 +29,8 @@ use polkadot_primitives::{Balance, CollatorPair, HeadData, Id as ParaId, Validat
 use polkadot_runtime_common::BlockHashCount;
 use polkadot_runtime_parachains::paras::{ParaGenesisArgs, ParaKind};
 use polkadot_service::{
-	Error, FullClient, IsParachainNode, NewFull, OverseerGen, PrometheusConfig,
+	Error, FullClient, IdentifyNetworkBackend, IsParachainNode, NewFull, OverseerGen,
+	PrometheusConfig,
 };
 use polkadot_test_runtime::{
 	ParasCall, ParasSudoWrapperCall, Runtime, SignedPayload, SudoCall, TxExtension,
@@ -80,7 +81,11 @@ pub fn new_full<OverseerGenerator: OverseerGen>(
 ) -> Result<NewFull, Error> {
 	let workers_path = Some(workers_path.unwrap_or_else(get_relative_workers_path_for_test));
 
-	match config.network.network_backend {
+	// If the network backend is unspecified, use the default for the given chain.
+	let default_backend = config.chain_spec.network_backend();
+	let network_backend = config.network.network_backend.unwrap_or(default_backend);
+
+	match network_backend {
 		sc_network::config::NetworkBackendType::Libp2p =>
 			polkadot_service::new_full::<_, sc_network::NetworkWorker<_, _>>(
 				config,

polkadot/node/test/service/src/lib.rs

@@ -0,0 +1,29 @@
+title: Make litep2p the default backend in Kusama
+
+doc:
+  - audience: Node Operator
+    description: |
+      This PR makes the litep2p backend the default network backend in Kusama, but also for system chains.
+      We performed a gradual rollout in Kusama by asking validators to manually switch to litep2p.
+      The rollout went smoothly, with 250 validators running litep2p without issues. This PR represents the next step in testing the backend at scale.
+
+  - audience: Node Dev
+    description: |
+      A new trait `IdentifyNetworkBackend` is introduced for the polkadot-service. The purpose of the trait
+      is to specify the default network backend for individual chains. For Kusama based chains, the default
+      is now litep2p. For other chains, the default remains unchanged to libp2p.
+      The network backend field of the network configuration is made optional to accomodate for this change.
+
+crates:
+  - name: sc-network
+    bump: minor
+  - name: sc-network-types
+    bump: minor
+  - name: polkadot-service
+    bump: minor
+  - name: sc-cli
+    bump: patch
+  - name: cumulus-relay-chain-minimal-node
+    bump: patch
+  - name: polkadot-omni-node-lib
+    bump: patch

prdoc/pr_7866.prdoc

@@ -817,7 +817,7 @@ pub fn new_full(config: Configuration, cli: Cli) -> Result<TaskManager, ServiceE
 	let mixnet_config = cli.mixnet_params.config(config.role.is_authority());
 	let database_path = config.database.path().map(Path::to_path_buf);
 
-	let task_manager = match config.network.network_backend {
+	let task_manager = match config.network.network_backend.unwrap_or_default() {
 		sc_network::config::NetworkBackendType::Libp2p => {
 			let task_manager = new_full_base::<sc_network::NetworkWorker<_, _>>(
 				config,

substrate/bin/node/cli/src/service.rs

@@ -178,11 +178,10 @@ pub struct NetworkParams {
 		long,
 		value_enum,
 		value_name = "NETWORK_BACKEND",
-		default_value_t = NetworkBackendType::Libp2p,
 		ignore_case = true,
 		verbatim_doc_comment
 	)]
-	pub network_backend: NetworkBackendType,
+	pub network_backend: Option<NetworkBackendType>,
 }
 
 impl NetworkParams {
@@ -278,7 +277,7 @@ impl NetworkParams {
 			yamux_window_size: None,
 			ipfs_server: self.ipfs_server,
 			sync_mode: self.sync.into(),
-			network_backend: self.network_backend.into(),
+			network_backend: self.network_backend.map(Into::into),
 		}
 	}
 }

substrate/client/cli/src/params/network_params.rs

@@ -672,7 +672,7 @@ pub struct NetworkConfiguration {
 	pub yamux_window_size: Option<u32>,
 
 	/// Networking backend used for P2P communication.
-	pub network_backend: NetworkBackendType,
+	pub network_backend: Option<NetworkBackendType>,
 }
 
 impl NetworkConfiguration {
@@ -705,7 +705,7 @@ impl NetworkConfiguration {
 				.expect("value is a constant; constant is non-zero; qed."),
 			yamux_window_size: None,
 			ipfs_server: false,
-			network_backend: NetworkBackendType::Libp2p,
+			network_backend: None,
 		}
 	}
 
@@ -931,9 +931,10 @@ impl<B: BlockT + 'static, H: ExHashT, N: NetworkBackend<B, H>> FullNetworkConfig
 }
 
 /// Network backend type.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Default, Copy)]
 pub enum NetworkBackendType {
 	/// Use libp2p for P2P networking.
+	#[default]
 	Libp2p,
 
 	/// Use litep2p for P2P networking.

substrate/client/network/src/config.rs

@@ -117,7 +117,7 @@ pub fn run() -> sc_cli::Result<()> {
 		None => {
 			let runner = cli.create_runner(&cli.run)?;
 			runner.run_node_until_exit(|config| async move {
-				match config.network.network_backend {
+				match config.network.network_backend.unwrap_or_default() {
 					sc_network::config::NetworkBackendType::Libp2p =>
 						service::new_full::<sc_network::NetworkWorker<_, _>>(config, cli.consensus)
 							.map_err(sc_cli::Error::Service),

templates/minimal/node/src/command.rs

@@ -178,7 +178,7 @@ pub fn run() -> sc_cli::Result<()> {
 		None => {
 			let runner = cli.create_runner(&cli.run)?;
 			runner.run_node_until_exit(|config| async move {
-				match config.network.network_backend {
+				match config.network.network_backend.unwrap_or_default() {
 					sc_network::config::NetworkBackendType::Libp2p => service::new_full::<
 						sc_network::NetworkWorker<
 							solochain_template_runtime::opaque::Block,