Integrate litep2p into Polkadot SDK

Cargo.toml

@@ -261,7 +261,6 @@ members = [
 	"substrate/client/mixnet",
 	"substrate/client/network",
 	"substrate/client/network-gossip",
-	"substrate/client/network/bitswap",
 	"substrate/client/network/common",
 	"substrate/client/network/light",
 	"substrate/client/network/statement",

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

@@ -47,7 +47,6 @@ use sc_network::{NetworkStateInfo, NotificationService};
 use sc_service::TaskManager;
 use sc_utils::mpsc::tracing_unbounded;
 
-use cumulus_primitives_core::relay_chain::{Block, Hash as PHash};
 use cumulus_relay_chain_interface::RelayChainError;
 
 use crate::BlockChainRpcClient;
@@ -57,7 +56,7 @@ pub(crate) struct CollatorOverseerGenArgs<'a> {
 	/// Runtime client generic, providing the `ProvieRuntimeApi` trait besides others.
 	pub runtime_client: Arc<BlockChainRpcClient>,
 	/// Underlying network service implementation.
-	pub network_service: Arc<sc_network::NetworkService<Block, PHash>>,
+	pub network_service: Arc<dyn sc_network::service::traits::NetworkService>,
 	/// Syncing oracle.
 	pub sync_oracle: Box<dyn sp_consensus::SyncOracle + Send>,
 	/// Underlying authority discovery service.

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

@@ -27,11 +27,15 @@ 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 sc_authority_discovery::Service as AuthorityDiscoveryService;
-use sc_network::{config::FullNetworkConfiguration, Event, NetworkEventStream, NetworkService};
+use sc_network::{
+	config::FullNetworkConfiguration, service::traits::NetworkService, Event, NetworkBackend,
+	NetworkEventStream,
+};
 use sc_service::{config::PrometheusConfig, Configuration, TaskManager};
 use sp_runtime::{app_crypto::Pair, traits::Block as BlockT};
 
@@ -50,7 +54,7 @@ fn build_authority_discovery_service<Block: BlockT>(
 	task_manager: &TaskManager,
 	client: Arc<BlockChainRpcClient>,
 	config: &Configuration,
-	network: Arc<NetworkService<Block, <Block as BlockT>::Hash>>,
+	network: Arc<dyn NetworkService>,
 	prometheus_registry: Option<Registry>,
 ) -> AuthorityDiscoveryService {
 	let auth_disc_publish_non_global_ips = config.network.allow_non_globals_in_dht;
@@ -69,7 +73,7 @@ fn build_authority_discovery_service<Block: BlockT>(
 			..Default::default()
 		},
 		client,
-		network,
+		Arc::new(network.clone()),
 		Box::pin(dht_event_stream),
 		authority_discovery_role,
 		prometheus_registry,
@@ -89,12 +93,22 @@ async fn build_interface(
 	client: RelayChainRpcClient,
 ) -> RelayChainResult<(Arc<(dyn RelayChainInterface + 'static)>, Option<CollatorPair>)> {
 	let collator_pair = CollatorPair::generate().0;
-	let collator_node = new_minimal_relay_chain(
-		polkadot_config,
-		collator_pair.clone(),
-		Arc::new(BlockChainRpcClient::new(client.clone())),
-	)
-	.await?;
+	let collator_node = match polkadot_config.network.network_backend {
+		sc_network::config::NetworkBackendType::Libp2p =>
+			new_minimal_relay_chain::<RelayBlock, sc_network::NetworkWorker<RelayBlock, RelayHash>>(
+				polkadot_config,
+				collator_pair.clone(),
+				Arc::new(BlockChainRpcClient::new(client.clone())),
+			)
+			.await?,
+		sc_network::config::NetworkBackendType::Litep2p =>
+			new_minimal_relay_chain::<RelayBlock, sc_network::Litep2pNetworkBackend>(
+				polkadot_config,
+				collator_pair.clone(),
+				Arc::new(BlockChainRpcClient::new(client.clone())),
+			)
+			.await?,
+	};
 	task_manager.add_child(collator_node.task_manager);
 	Ok((
 		Arc::new(RelayChainRpcInterface::new(client, collator_node.overseer_handle)),
@@ -140,6 +154,7 @@ pub async fn build_minimal_relay_chain_node_light_client(
 
 	build_interface(polkadot_config, task_manager, client).await
 }
+
 /// Builds a minimal relay chain node. Chain data is fetched
 /// via [`BlockChainRpcClient`] and fed into the overseer and its subsystems.
 ///
@@ -152,13 +167,18 @@ pub async fn build_minimal_relay_chain_node_light_client(
 /// - NetworkBridgeTx
 /// - RuntimeApi
 #[sc_tracing::logging::prefix_logs_with("Relaychain")]
-async fn new_minimal_relay_chain(
+async fn new_minimal_relay_chain<Block: BlockT, Network: NetworkBackend<RelayBlock, RelayHash>>(
 	config: Configuration,
 	collator_pair: CollatorPair,
 	relay_chain_rpc_client: Arc<BlockChainRpcClient>,
 ) -> Result<NewMinimalNode, RelayChainError> {
 	let role = config.role.clone();
-	let mut net_config = sc_network::config::FullNetworkConfiguration::new(&config.network);
+	let mut net_config =
+		sc_network::config::FullNetworkConfiguration::<_, _, Network>::new(&config.network);
+	let metrics = Network::register_notification_metrics(
+		config.prometheus_config.as_ref().map(|cfg| &cfg.registry),
+	);
+	let peer_store_handle = net_config.peer_store_handle();
 
 	let prometheus_registry = config.prometheus_registry();
 	let task_manager = TaskManager::new(config.tokio_handle.clone(), prometheus_registry)?;
@@ -175,13 +195,18 @@ async fn new_minimal_relay_chain(
 	let peer_set_protocol_names =
 		PeerSetProtocolNames::new(genesis_hash, config.chain_spec.fork_id());
 	let is_authority = if role.is_authority() { IsAuthority::Yes } else { IsAuthority::No };
-	let notification_services = peer_sets_info(is_authority, &peer_set_protocol_names)
-		.into_iter()
-		.map(|(config, (peerset, service))| {
-			net_config.add_notification_protocol(config);
-			(peerset, service)
-		})
-		.collect::<std::collections::HashMap<PeerSet, Box<dyn sc_network::NotificationService>>>();
+	let notification_services = peer_sets_info::<_, Network>(
+		is_authority,
+		&peer_set_protocol_names,
+		metrics.clone(),
+		Arc::clone(&peer_store_handle),
+	)
+	.into_iter()
+	.map(|(config, (peerset, service))| {
+		net_config.add_notification_protocol(config);
+		(peerset, service)
+	})
+	.collect::<std::collections::HashMap<PeerSet, Box<dyn sc_network::NotificationService>>>();
 
 	let request_protocol_names = ReqProtocolNames::new(genesis_hash, config.chain_spec.fork_id());
 	let (collation_req_receiver_v1, collation_req_receiver_v2, available_data_req_receiver) =
@@ -191,16 +216,17 @@ async fn new_minimal_relay_chain(
 		.chain_get_header(None)
 		.await?
 		.ok_or_else(|| RelayChainError::RpcCallError("Unable to fetch best header".to_string()))?;
-	let (network, network_starter, sync_oracle) = build_collator_network(
+	let (network, network_starter, sync_oracle) = build_collator_network::<Network>(
 		&config,
 		net_config,
 		task_manager.spawn_handle(),
 		genesis_hash,
 		best_header,
+		metrics,
 	)
 	.map_err(|e| RelayChainError::Application(Box::new(e) as Box<_>))?;
 
-	let authority_discovery_service = build_authority_discovery_service(
+	let authority_discovery_service = build_authority_discovery_service::<Block>(
 		&task_manager,
 		relay_chain_rpc_client.clone(),
 		&config,
@@ -232,24 +258,28 @@ async fn new_minimal_relay_chain(
 	Ok(NewMinimalNode { task_manager, overseer_handle })
 }
 
-fn build_request_response_protocol_receivers(
+fn build_request_response_protocol_receivers<
+	Block: BlockT,
+	Network: NetworkBackend<Block, <Block as BlockT>::Hash>,
+>(
 	request_protocol_names: &ReqProtocolNames,
-	config: &mut FullNetworkConfiguration,
+	config: &mut FullNetworkConfiguration<Block, <Block as BlockT>::Hash, Network>,
 ) -> (
 	IncomingRequestReceiver<v1::CollationFetchingRequest>,
 	IncomingRequestReceiver<v2::CollationFetchingRequest>,
 	IncomingRequestReceiver<v1::AvailableDataFetchingRequest>,
 ) {
 	let (collation_req_receiver_v1, cfg) =
-		IncomingRequest::get_config_receiver(request_protocol_names);
+		IncomingRequest::get_config_receiver::<_, Network>(request_protocol_names);
 	config.add_request_response_protocol(cfg);
 	let (collation_req_receiver_v2, cfg) =
-		IncomingRequest::get_config_receiver(request_protocol_names);
+		IncomingRequest::get_config_receiver::<_, Network>(request_protocol_names);
 	config.add_request_response_protocol(cfg);
 	let (available_data_req_receiver, cfg) =
-		IncomingRequest::get_config_receiver(request_protocol_names);
+		IncomingRequest::get_config_receiver::<_, Network>(request_protocol_names);
 	config.add_request_response_protocol(cfg);
-	let cfg = Protocol::ChunkFetchingV1.get_outbound_only_config(request_protocol_names);
+	let cfg =
+		Protocol::ChunkFetchingV1.get_outbound_only_config::<_, Network>(request_protocol_names);
 	config.add_request_response_protocol(cfg);
 	(collation_req_receiver_v1, collation_req_receiver_v2, available_data_req_receiver)
 }

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

@@ -15,60 +15,56 @@
 // along with Cumulus.  If not, see <http://www.gnu.org/licenses/>.
 
 use polkadot_core_primitives::{Block, Hash, Header};
-use sp_runtime::traits::{Block as BlockT, NumberFor};
+use sp_runtime::traits::NumberFor;
 
 use sc_network::{
 	config::{
-		NetworkConfiguration, NonDefaultSetConfig, NonReservedPeerMode, NotificationHandshake,
-		ProtocolId, SetConfig,
+		NetworkConfiguration, NonReservedPeerMode, NotificationHandshake, PeerStore, ProtocolId,
+		SetConfig,
 	},
-	peer_store::PeerStore,
-	NetworkService,
+	peer_store::PeerStoreProvider,
+	service::traits::NetworkService,
+	NotificationMetrics,
 };
 
-use sc_network::{config::FullNetworkConfiguration, NotificationService};
+use sc_network::{config::FullNetworkConfiguration, NetworkBackend, NotificationService};
 use sc_network_common::{role::Roles, sync::message::BlockAnnouncesHandshake};
 use sc_service::{error::Error, Configuration, NetworkStarter, SpawnTaskHandle};
 
 use std::{iter, sync::Arc};
 
 /// Build the network service, the network status sinks and an RPC sender.
-pub(crate) fn build_collator_network(
+pub(crate) fn build_collator_network<Network: NetworkBackend<Block, Hash>>(
 	config: &Configuration,
-	mut full_network_config: FullNetworkConfiguration,
+	mut network_config: FullNetworkConfiguration<Block, Hash, Network>,
 	spawn_handle: SpawnTaskHandle,
 	genesis_hash: Hash,
 	best_header: Header,
+	metrics: NotificationMetrics,
 ) -> Result<
-	(Arc<NetworkService<Block, Hash>>, NetworkStarter, Box<dyn sp_consensus::SyncOracle + Send>),
+	(Arc<dyn NetworkService>, NetworkStarter, Box<dyn sp_consensus::SyncOracle + Send>),
 	Error,
 > {
 	let protocol_id = config.protocol_id();
-	let (block_announce_config, _notification_service) = get_block_announce_proto_config::<Block>(
+	let (block_announce_config, _notification_service) = get_block_announce_proto_config::<Network>(
 		protocol_id.clone(),
 		&None,
 		Roles::from(&config.role),
 		best_header.number,
 		best_header.hash(),
 		genesis_hash,
+		metrics,
+		network_config.peer_store_handle(),
 	);
 
 	// Since this node has no syncing, we do not want light-clients to connect to it.
 	// Here we set any potential light-client slots to 0.
-	adjust_network_config_light_in_peers(&mut full_network_config.network_config);
-
-	let peer_store = PeerStore::new(
-		full_network_config
-			.network_config
-			.boot_nodes
-			.iter()
-			.map(|bootnode| bootnode.peer_id)
-			.collect(),
-	);
-	let peer_store_handle = peer_store.handle();
+	adjust_network_config_light_in_peers(&mut network_config.network_config);
+
+	let peer_store = network_config.take_peer_store();
 	spawn_handle.spawn("peer-store", Some("networking"), peer_store.run());
 
-	let network_params = sc_network::config::Params::<Block> {
+	let network_params = sc_network::config::Params::<Block, Hash, Network> {
 		role: config.role.clone(),
 		executor: {
 			let spawn_handle = Clone::clone(&spawn_handle);
@@ -77,16 +73,16 @@ pub(crate) fn build_collator_network(
 			})
 		},
 		fork_id: None,
-		network_config: full_network_config,
-		peer_store: peer_store_handle,
+		network_config,
 		genesis_hash,
 		protocol_id,
 		metrics_registry: config.prometheus_config.as_ref().map(|config| config.registry.clone()),
 		block_announce_config,
+		bitswap_config: None,
 	};
 
-	let network_worker = sc_network::NetworkWorker::new(network_params)?;
-	let network_service = network_worker.service().clone();
+	let network_worker = Network::new(network_params)?;
+	let network_service = network_worker.network_service();
 
 	let (network_start_tx, network_start_rx) = futures::channel::oneshot::channel();
 
@@ -139,14 +135,16 @@ impl sp_consensus::SyncOracle for SyncOracle {
 	}
 }
 
-fn get_block_announce_proto_config<B: BlockT>(
+fn get_block_announce_proto_config<Network: NetworkBackend<Block, Hash>>(
 	protocol_id: ProtocolId,
 	fork_id: &Option<String>,
 	roles: Roles,
-	best_number: NumberFor<B>,
-	best_hash: B::Hash,
-	genesis_hash: B::Hash,
-) -> (NonDefaultSetConfig, Box<dyn NotificationService>) {
+	best_number: NumberFor<Block>,
+	best_hash: Hash,
+	genesis_hash: Hash,
+	metrics: NotificationMetrics,
+	peer_store_handle: Arc<dyn PeerStoreProvider>,
+) -> (Network::NotificationProtocolConfig, Box<dyn NotificationService>) {
 	let block_announces_protocol = {
 		let genesis_hash = genesis_hash.as_ref();
 		if let Some(ref fork_id) = fork_id {
@@ -156,11 +154,11 @@ fn get_block_announce_proto_config<B: BlockT>(
 		}
 	};
 
-	NonDefaultSetConfig::new(
+	Network::notification_config(
 		block_announces_protocol.into(),
 		iter::once(format!("/{}/block-announces/1", protocol_id.as_ref()).into()).collect(),
 		1024 * 1024,
-		Some(NotificationHandshake::new(BlockAnnouncesHandshake::<B>::build(
+		Some(NotificationHandshake::new(BlockAnnouncesHandshake::<Block>::build(
 			roles,
 			best_number,
 			best_hash,
@@ -174,5 +172,7 @@ fn get_block_announce_proto_config<B: BlockT>(
 			reserved_nodes: Vec::new(),
 			non_reserved_mode: NonReservedPeerMode::Deny,
 		},
+		metrics,
+		peer_store_handle,
 	)
 }