Bump dependencies (#1180)

* substrate: d0f6c1c60da22e04dd25c2eca46ebfe6f1571af0
polkadot: dd4b2e6a34a08a01b876d14641e99e7011be3463
cumulus: 9379cd6c18

* fmt

* fixed lost refs

* spelling

* benckhmarks

* fmt

bridges/bin/rialto/node/src/chain_spec.rs

@@ -264,7 +264,6 @@ fn testnet_genesis(
 				ump_service_total_weight: 4 * 1_000_000_000,
 				max_upward_message_size: 1024 * 1024,
 				max_upward_message_num_per_candidate: 5,
-				_hrmp_open_request_ttl: 5,
 				hrmp_sender_deposit: 0,
 				hrmp_recipient_deposit: 0,
 				hrmp_channel_max_capacity: 8,

bridges/bin/rialto/node/src/overseer.rs

@@ -23,6 +23,7 @@
 use crate::service::{AuthorityDiscoveryApi, Error};
 use rialto_runtime::{opaque::Block, Hash};
 
+use lru::LruCache;
 use polkadot_availability_distribution::IncomingRequestReceivers;
 use polkadot_node_core_approval_voting::Config as ApprovalVotingConfig;
 use polkadot_node_core_av_store::Config as AvailabilityConfig;
@@ -30,7 +31,10 @@ use polkadot_node_core_candidate_validation::Config as CandidateValidationConfig
 use polkadot_node_core_chain_selection::Config as ChainSelectionConfig;
 use polkadot_node_core_dispute_coordinator::Config as DisputeCoordinatorConfig;
 use polkadot_node_network_protocol::request_response::{v1 as request_v1, IncomingRequestReceiver};
-use polkadot_overseer::{AllSubsystems, BlockInfo, Overseer, OverseerHandle};
+use polkadot_overseer::{
+	metrics::Metrics as OverseerMetrics, BlockInfo, MetricsTrait, Overseer, OverseerBuilder,
+	OverseerConnector, OverseerHandle,
+};
 use polkadot_primitives::v1::ParachainHost;
 use sc_authority_discovery::Service as AuthorityDiscoveryService;
 use sc_client_api::AuxStore;
@@ -107,12 +111,11 @@ where
 	pub dispute_coordinator_config: DisputeCoordinatorConfig,
 }
 
-/// Create a default, unaltered set of subsystems.
-///
-/// A convenience for usage with malus, to avoid
-/// repetitive code across multiple behavior strain implementations.
-pub fn create_default_subsystems<Spawner, RuntimeClient>(
+/// Obtain a prepared `OverseerBuilder`, that is initialized
+/// with all default values.
+pub fn prepared_overseer_builder<'a, Spawner, RuntimeClient>(
 	OverseerGenArgs {
+		leaves,
 		keystore,
 		runtime_client,
 		parachains_db,
@@ -120,6 +123,7 @@ pub fn create_default_subsystems<Spawner, RuntimeClient>(
 		authority_discovery_service,
 		pov_req_receiver,
 		chunk_req_receiver,
+		collation_req_receiver: _,
 		available_data_req_receiver,
 		statement_req_receiver,
 		dispute_req_receiver,
@@ -130,10 +134,11 @@ pub fn create_default_subsystems<Spawner, RuntimeClient>(
 		candidate_validation_config,
 		chain_selection_config,
 		dispute_coordinator_config,
-		..
-	}: OverseerGenArgs<'_, Spawner, RuntimeClient>,
+	}: OverseerGenArgs<'a, Spawner, RuntimeClient>,
 ) -> Result<
-	AllSubsystems<
+	OverseerBuilder<
+		Spawner,
+		Arc<RuntimeClient>,
 		CandidateValidationSubsystem,
 		CandidateBackingSubsystem<Spawner>,
 		StatementDistributionSubsystem,
@@ -153,7 +158,7 @@ pub fn create_default_subsystems<Spawner, RuntimeClient>(
 		CollatorProtocolSubsystem,
 		ApprovalDistributionSubsystem,
 		ApprovalVotingSubsystem,
-		GossipSupportSubsystem,
+		GossipSupportSubsystem<AuthorityDiscoveryService>,
 		DisputeCoordinatorSubsystem,
 		DisputeParticipationSubsystem,
 		DisputeDistributionSubsystem<AuthorityDiscoveryService>,
@@ -167,86 +172,104 @@ where
 	Spawner: 'static + SpawnNamed + Clone + Unpin,
 {
 	use polkadot_node_subsystem_util::metrics::Metrics;
+	use std::iter::FromIterator;
 
-	let all_subsystems = AllSubsystems {
-		availability_distribution: AvailabilityDistributionSubsystem::new(
+	let metrics = <OverseerMetrics as MetricsTrait>::register(registry)?;
+
+	let builder = Overseer::builder()
+		.availability_distribution(AvailabilityDistributionSubsystem::new(
 			keystore.clone(),
 			IncomingRequestReceivers { pov_req_receiver, chunk_req_receiver },
 			Metrics::register(registry)?,
-		),
-		availability_recovery: AvailabilityRecoverySubsystem::with_chunks_only(
+		))
+		.availability_recovery(AvailabilityRecoverySubsystem::with_chunks_only(
 			available_data_req_receiver,
 			Metrics::register(registry)?,
-		),
-		availability_store: AvailabilityStoreSubsystem::new(
+		))
+		.availability_store(AvailabilityStoreSubsystem::new(
 			parachains_db.clone(),
 			availability_config,
 			Metrics::register(registry)?,
-		),
-		bitfield_distribution: BitfieldDistributionSubsystem::new(Metrics::register(registry)?),
-		bitfield_signing: BitfieldSigningSubsystem::new(
+		))
+		.bitfield_distribution(BitfieldDistributionSubsystem::new(Metrics::register(registry)?))
+		.bitfield_signing(BitfieldSigningSubsystem::new(
 			spawner.clone(),
 			keystore.clone(),
 			Metrics::register(registry)?,
-		),
-		candidate_backing: CandidateBackingSubsystem::new(
+		))
+		.candidate_backing(CandidateBackingSubsystem::new(
 			spawner.clone(),
 			keystore.clone(),
 			Metrics::register(registry)?,
-		),
-		candidate_validation: CandidateValidationSubsystem::with_config(
+		))
+		.candidate_validation(CandidateValidationSubsystem::with_config(
 			candidate_validation_config,
 			Metrics::register(registry)?, // candidate-validation metrics
 			Metrics::register(registry)?, // validation host metrics
-		),
-		chain_api: ChainApiSubsystem::new(runtime_client.clone(), Metrics::register(registry)?),
-		collation_generation: CollationGenerationSubsystem::new(Metrics::register(registry)?),
-		collator_protocol: CollatorProtocolSubsystem::new(ProtocolSide::Validator {
+		))
+		.chain_api(ChainApiSubsystem::new(runtime_client.clone(), Metrics::register(registry)?))
+		.collation_generation(CollationGenerationSubsystem::new(Metrics::register(registry)?))
+		.collator_protocol(CollatorProtocolSubsystem::new(ProtocolSide::Validator {
 			keystore: keystore.clone(),
 			eviction_policy: Default::default(),
 			metrics: Metrics::register(registry)?,
-		}),
-		network_bridge: NetworkBridgeSubsystem::new(
+		}))
+		.network_bridge(NetworkBridgeSubsystem::new(
 			network_service.clone(),
 			authority_discovery_service.clone(),
 			Box::new(network_service.clone()),
 			Metrics::register(registry)?,
-		),
-		provisioner: ProvisionerSubsystem::new(spawner.clone(), (), Metrics::register(registry)?),
-		runtime_api: RuntimeApiSubsystem::new(
-			runtime_client,
+		))
+		.provisioner(ProvisionerSubsystem::new(spawner.clone(), (), Metrics::register(registry)?))
+		.runtime_api(RuntimeApiSubsystem::new(
+			runtime_client.clone(),
 			Metrics::register(registry)?,
-			spawner,
-		),
-		statement_distribution: StatementDistributionSubsystem::new(
+			spawner.clone(),
+		))
+		.statement_distribution(StatementDistributionSubsystem::new(
 			keystore.clone(),
 			statement_req_receiver,
 			Metrics::register(registry)?,
-		),
-		approval_distribution: ApprovalDistributionSubsystem::new(Metrics::register(registry)?),
-		approval_voting: ApprovalVotingSubsystem::with_config(
+		))
+		.approval_distribution(ApprovalDistributionSubsystem::new(Metrics::register(registry)?))
+		.approval_voting(ApprovalVotingSubsystem::with_config(
 			approval_voting_config,
 			parachains_db.clone(),
 			keystore.clone(),
-			Box::new(network_service),
+			Box::new(network_service.clone()),
 			Metrics::register(registry)?,
-		),
-		gossip_support: GossipSupportSubsystem::new(keystore.clone()),
-		dispute_coordinator: DisputeCoordinatorSubsystem::new(
+		))
+		.gossip_support(GossipSupportSubsystem::new(
+			keystore.clone(),
+			authority_discovery_service.clone(),
+		))
+		.dispute_coordinator(DisputeCoordinatorSubsystem::new(
 			parachains_db.clone(),
 			dispute_coordinator_config,
 			keystore.clone(),
-		),
-		dispute_participation: DisputeParticipationSubsystem::new(),
-		dispute_distribution: DisputeDistributionSubsystem::new(
-			keystore,
-			dispute_req_receiver,
-			authority_discovery_service,
 			Metrics::register(registry)?,
-		),
-		chain_selection: ChainSelectionSubsystem::new(chain_selection_config, parachains_db),
-	};
-	Ok(all_subsystems)
+		))
+		.dispute_participation(DisputeParticipationSubsystem::new())
+		.dispute_distribution(DisputeDistributionSubsystem::new(
+			keystore.clone(),
+			dispute_req_receiver,
+			authority_discovery_service.clone(),
+			Metrics::register(registry)?,
+		))
+		.chain_selection(ChainSelectionSubsystem::new(chain_selection_config, parachains_db))
+		.leaves(Vec::from_iter(
+			leaves
+				.into_iter()
+				.map(|BlockInfo { hash, parent_hash: _, number }| (hash, number)),
+		))
+		.activation_external_listeners(Default::default())
+		.span_per_active_leaf(Default::default())
+		.active_leaves(Default::default())
+		.supports_parachains(runtime_client)
+		.known_leaves(LruCache::new(KNOWN_LEAVES_CACHE_SIZE))
+		.metrics(metrics)
+		.spawner(spawner);
+	Ok(builder)
 }
 
 /// Trait for the `fn` generating the overseer.
@@ -255,9 +278,10 @@ where
 /// would do.
 pub trait OverseerGen {
 	/// Overwrite the full generation of the overseer, including the subsystems.
-	fn generate<Spawner, RuntimeClient>(
+	fn generate<'a, Spawner, RuntimeClient>(
 		&self,
-		args: OverseerGenArgs<'_, Spawner, RuntimeClient>,
+		connector: OverseerConnector,
+		args: OverseerGenArgs<'a, Spawner, RuntimeClient>,
 	) -> Result<(Overseer<Spawner, Arc<RuntimeClient>>, OverseerHandle), Error>
 	where
 		RuntimeClient: 'static + ProvideRuntimeApi<Block> + HeaderBackend<Block> + AuxStore,
@@ -265,34 +289,31 @@ pub trait OverseerGen {
 		Spawner: 'static + SpawnNamed + Clone + Unpin,
 	{
 		let gen = RealOverseerGen;
-		RealOverseerGen::generate::<Spawner, RuntimeClient>(&gen, args)
+		RealOverseerGen::generate::<Spawner, RuntimeClient>(&gen, connector, args)
 	}
 	// It would be nice to make `create_subsystems` part of this trait,
 	// but the amount of generic arguments that would be required as
 	// as consequence make this rather annoying to implement and use.
 }
 
+use polkadot_overseer::KNOWN_LEAVES_CACHE_SIZE;
+
 /// The regular set of subsystems.
 pub struct RealOverseerGen;
 
 impl OverseerGen for RealOverseerGen {
-	fn generate<Spawner, RuntimeClient>(
+	fn generate<'a, Spawner, RuntimeClient>(
 		&self,
-		args: OverseerGenArgs<'_, Spawner, RuntimeClient>,
+		connector: OverseerConnector,
+		args: OverseerGenArgs<'a, Spawner, RuntimeClient>,
 	) -> Result<(Overseer<Spawner, Arc<RuntimeClient>>, OverseerHandle), Error>
 	where
 		RuntimeClient: 'static + ProvideRuntimeApi<Block> + HeaderBackend<Block> + AuxStore,
 		RuntimeClient::Api: ParachainHost<Block> + BabeApi<Block> + AuthorityDiscoveryApi<Block>,
 		Spawner: 'static + SpawnNamed + Clone + Unpin,
 	{
-		let spawner = args.spawner.clone();
-		let leaves = args.leaves.clone();
-		let runtime_client = args.runtime_client.clone();
-		let registry = args.registry;
-
-		let all_subsystems = create_default_subsystems::<Spawner, RuntimeClient>(args)?;
-
-		Overseer::new(leaves, all_subsystems, registry, runtime_client, spawner)
+		prepared_overseer_builder(args)?
+			.build_with_connector(connector)
 			.map_err(|e| e.into())
 	}
 }

bridges/bin/rialto/node/src/service.rs

@@ -33,7 +33,7 @@ use polkadot_node_core_candidate_validation::Config as CandidateValidationConfig
 use polkadot_node_core_chain_selection::Config as ChainSelectionConfig;
 use polkadot_node_core_dispute_coordinator::Config as DisputeCoordinatorConfig;
 use polkadot_node_network_protocol::request_response::IncomingRequest;
-use polkadot_overseer::BlockInfo;
+use polkadot_overseer::{BlockInfo, OverseerConnector};
 use polkadot_primitives::v1::BlockId;
 use rialto_runtime::{self, opaque::Block, RuntimeApi};
 use sc_client_api::ExecutorProvider;
@@ -47,7 +47,7 @@ use sp_runtime::traits::{BlakeTwo256, Block as BlockT};
 use std::{sync::Arc, time::Duration};
 use substrate_prometheus_endpoint::Registry;
 
-pub use polkadot_overseer::{Handle, Overseer, OverseerHandle};
+pub use polkadot_overseer::Handle;
 pub use polkadot_primitives::v1::ParachainHost;
 pub use sc_client_api::AuxStore;
 pub use sp_authority_discovery::AuthorityDiscoveryApi;
@@ -432,6 +432,8 @@ where
 
 	let prometheus_registry = config.prometheus_registry().cloned();
 
+	let overseer_connector = OverseerConnector::default();
+
 	let shared_voter_state = rpc_setup;
 	let auth_disc_publish_non_global_ips = config.network.allow_non_globals_in_dht;
 
@@ -462,6 +464,7 @@ where
 	let warp_sync = Arc::new(sc_finality_grandpa::warp_proof::NetworkProvider::new(
 		backend.clone(),
 		import_setup.1.shared_authority_set().clone(),
+		vec![],
 	));
 
 	let (network, system_rpc_tx, network_starter) =
@@ -586,50 +589,55 @@ where
 
 	let overseer_handle = if let Some((authority_discovery_service, keystore)) = maybe_params {
 		let (overseer, overseer_handle) = overseer_gen
-			.generate::<sc_service::SpawnTaskHandle, FullClient>(OverseerGenArgs {
-				leaves: active_leaves,
-				keystore,
-				runtime_client: overseer_client.clone(),
-				parachains_db,
-				availability_config,
-				approval_voting_config,
-				network_service: network.clone(),
-				authority_discovery_service,
-				registry: prometheus_registry.as_ref(),
-				spawner,
-				candidate_validation_config,
-				available_data_req_receiver,
-				chain_selection_config,
-				chunk_req_receiver,
-				collation_req_receiver,
-				dispute_coordinator_config,
-				dispute_req_receiver,
-				pov_req_receiver,
-				statement_req_receiver,
-			})?;
-		let handle = Handle::Connected(overseer_handle);
-		let handle_clone = handle.clone();
+			.generate::<sc_service::SpawnTaskHandle, FullClient>(
+				overseer_connector,
+				OverseerGenArgs {
+					leaves: active_leaves,
+					keystore,
+					runtime_client: overseer_client.clone(),
+					parachains_db,
+					availability_config,
+					approval_voting_config,
+					network_service: network.clone(),
+					authority_discovery_service,
+					registry: prometheus_registry.as_ref(),
+					spawner,
+					candidate_validation_config,
+					available_data_req_receiver,
+					chain_selection_config,
+					chunk_req_receiver,
+					collation_req_receiver,
+					dispute_coordinator_config,
+					dispute_req_receiver,
+					pov_req_receiver,
+					statement_req_receiver,
+				},
+			)?;
+		let handle = Handle::new(overseer_handle.clone());
 
-		task_manager.spawn_essential_handle().spawn_blocking(
-			"overseer",
-			Box::pin(async move {
-				use futures::{pin_mut, select, FutureExt};
+		{
+			let handle = handle.clone();
+			task_manager.spawn_essential_handle().spawn_blocking(
+				"overseer",
+				Box::pin(async move {
+					use futures::{pin_mut, select, FutureExt};
 
-				let forward = polkadot_overseer::forward_events(overseer_client, handle_clone);
+					let forward = polkadot_overseer::forward_events(overseer_client, handle);
 
-				let forward = forward.fuse();
-				let overseer_fut = overseer.run().fuse();
+					let forward = forward.fuse();
+					let overseer_fut = overseer.run().fuse();
 
-				pin_mut!(overseer_fut);
-				pin_mut!(forward);
+					pin_mut!(overseer_fut);
+					pin_mut!(forward);
 
-				select! {
-					_ = forward => (),
-					_ = overseer_fut => (),
-					complete => (),
-				}
-			}),
-		);
+					select! {
+						_ = forward => (),
+						_ = overseer_fut => (),
+						complete => (),
+					}
+				}),
+			);
+		}
 
 		Some(handle)
 	} else {