Bump Substrate (#871)

* Bump Substrate

* Change usage of "Module" to "Pallet"

Related Substrate PR: https://github.com/paritytech/substrate/pull/8372

* Add `OnSetCode` config param

Related Substrate PR: https://github.com/paritytech/substrate/pull/8496

* Update Aura Slot duration time type

Related Substrate PR: https://github.com/paritytech/substrate/pull/8386

* Add `OnSetCode` to mock runtimes

* Add support for multiple justifications

Related Substrate PR: https://github.com/paritytech/substrate/pull/7640

* Use updated justification type in more places

* Make GenesisConfig type non-optional

Related Substrate PR: https://github.com/paritytech/substrate/pull/8275

* Update service to use updated telemetry

Related Substrate PR: https://github.com/paritytech/substrate/pull/8143

* Appease Clippy

bridges/bin/millau/node/Cargo.toml

@@ -39,6 +39,7 @@ sc-finality-grandpa-rpc = { git = "https://github.com/paritytech/substrate", bra
 sc-keystore = { git = "https://github.com/paritytech/substrate", branch = "master" }
 sc-rpc = { git = "https://github.com/paritytech/substrate", branch = "master" }
 sc-service = { git = "https://github.com/paritytech/substrate", branch = "master" }
+sc-telemetry = { git = "https://github.com/paritytech/substrate", branch = "master" }
 sc-transaction-pool = { git = "https://github.com/paritytech/substrate", branch = "master" }
 sp-consensus = { git = "https://github.com/paritytech/substrate", branch = "master" }
 sp-consensus-aura = { git = "https://github.com/paritytech/substrate", branch = "master" }

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

@@ -122,7 +122,7 @@ impl Alternative {
 							get_account_id_from_seed::<sr25519::Public>("Ferdie//stash"),
 							get_account_id_from_seed::<sr25519::Public>("George//stash"),
 							get_account_id_from_seed::<sr25519::Public>("Harry//stash"),
-							pallet_bridge_messages::Module::<
+							pallet_bridge_messages::Pallet::<
 								millau_runtime::Runtime,
 								pallet_bridge_messages::DefaultInstance,
 							>::relayer_fund_account_id(),
@@ -154,33 +154,33 @@ fn testnet_genesis(
 	_enable_println: bool,
 ) -> GenesisConfig {
 	GenesisConfig {
-		frame_system: Some(SystemConfig {
+		frame_system: SystemConfig {
 			code: WASM_BINARY.to_vec(),
 			changes_trie_config: Default::default(),
-		}),
-		pallet_balances: Some(BalancesConfig {
+		},
+		pallet_balances: BalancesConfig {
 			balances: endowed_accounts.iter().cloned().map(|k| (k, 1 << 50)).collect(),
-		}),
-		pallet_aura: Some(AuraConfig {
+		},
+		pallet_aura: AuraConfig {
 			authorities: Vec::new(),
-		}),
-		pallet_grandpa: Some(GrandpaConfig {
+		},
+		pallet_grandpa: GrandpaConfig {
 			authorities: Vec::new(),
-		}),
-		pallet_sudo: Some(SudoConfig { key: root_key }),
-		pallet_session: Some(SessionConfig {
+		},
+		pallet_sudo: SudoConfig { key: root_key },
+		pallet_session: SessionConfig {
 			keys: initial_authorities
 				.iter()
 				.map(|x| (x.0.clone(), x.0.clone(), session_keys(x.1.clone(), x.2.clone())))
 				.collect::<Vec<_>>(),
-		}),
-		pallet_bridge_grandpa_Instance1: Some(BridgeWestendGrandpaConfig {
+		},
+		pallet_bridge_grandpa_Instance1: BridgeWestendGrandpaConfig {
 			// for our deployments to avoid multiple same-nonces transactions:
 			// //Alice is already used to initialize Rialto<->Millau bridge
 			// => let's use //George to initialize Westend->Millau bridge
 			owner: Some(get_account_id_from_seed::<sr25519::Public>("George")),
 			..Default::default()
-		}),
+		},
 	}
 }
 

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

@@ -30,11 +30,13 @@
 
 use millau_runtime::{self, opaque::Block, RuntimeApi};
 use sc_client_api::{ExecutorProvider, RemoteBackend};
+use sc_consensus_aura::{ImportQueueParams, SlotProportion, StartAuraParams};
 use sc_executor::native_executor_instance;
 pub use sc_executor::NativeExecutor;
 use sc_finality_grandpa::SharedVoterState;
 use sc_keystore::LocalKeystore;
 use sc_service::{error::Error as ServiceError, Configuration, TaskManager};
+use sc_telemetry::{Telemetry, TelemetryWorker};
 use sp_consensus_aura::sr25519::AuthorityPair as AuraPair;
 use sp_inherents::InherentDataProviders;
 use std::sync::Arc;
@@ -70,6 +72,7 @@ pub fn new_partial(
 				AuraPair,
 			>,
 			sc_finality_grandpa::LinkHalf<Block, FullClient, FullSelectChain>,
+			Option<Telemetry>,
 		),
 	>,
 	ServiceError,
@@ -77,12 +80,30 @@ pub fn new_partial(
 	if config.keystore_remote.is_some() {
 		return Err(ServiceError::Other("Remote Keystores are not supported.".to_string()));
 	}
-	let inherent_data_providers = sp_inherents::InherentDataProviders::new();
+	let inherent_data_providers = InherentDataProviders::new();
 
-	let (client, backend, keystore_container, task_manager) =
-		sc_service::new_full_parts::<Block, RuntimeApi, Executor>(&config)?;
+	let telemetry = config
+		.telemetry_endpoints
+		.clone()
+		.filter(|x| !x.is_empty())
+		.map(|endpoints| -> Result<_, sc_telemetry::Error> {
+			let worker = TelemetryWorker::new(16)?;
+			let telemetry = worker.handle().new_telemetry(endpoints);
+			Ok((worker, telemetry))
+		})
+		.transpose()?;
+
+	let (client, backend, keystore_container, task_manager) = sc_service::new_full_parts::<Block, RuntimeApi, Executor>(
+		&config,
+		telemetry.as_ref().map(|(_, telemetry)| telemetry.handle()),
+	)?;
 	let client = Arc::new(client);
 
+	let telemetry = telemetry.map(|(worker, telemetry)| {
+		task_manager.spawn_handle().spawn("telemetry", worker.run());
+		telemetry
+	});
+
 	let select_chain = sc_consensus::LongestChain::new(backend.clone());
 
 	let transaction_pool = sc_transaction_pool::BasicPool::new_full(
@@ -93,22 +114,28 @@ pub fn new_partial(
 		client.clone(),
 	);
 
-	let (grandpa_block_import, grandpa_link) =
-		sc_finality_grandpa::block_import(client.clone(), &(client.clone() as Arc<_>), select_chain.clone())?;
+	let (grandpa_block_import, grandpa_link) = sc_finality_grandpa::block_import(
+		client.clone(),
+		&(client.clone() as Arc<_>),
+		select_chain.clone(),
+		telemetry.as_ref().map(|x| x.handle()),
+	)?;
 
 	let aura_block_import =
 		sc_consensus_aura::AuraBlockImport::<_, _, _, AuraPair>::new(grandpa_block_import.clone(), client.clone());
 
-	let import_queue = sc_consensus_aura::import_queue::<_, _, _, AuraPair, _, _>(
-		sc_consensus_aura::slot_duration(&*client)?,
-		aura_block_import.clone(),
-		Some(Box::new(grandpa_block_import)),
-		client.clone(),
-		inherent_data_providers.clone(),
-		&task_manager.spawn_essential_handle(),
-		config.prometheus_registry(),
-		sp_consensus::CanAuthorWithNativeVersion::new(client.executor().clone()),
-	)?;
+	let import_queue = sc_consensus_aura::import_queue::<AuraPair, _, _, _, _, _>(ImportQueueParams {
+		block_import: aura_block_import.clone(),
+		justification_import: Some(Box::new(grandpa_block_import)),
+		client: client.clone(),
+		inherent_data_providers: inherent_data_providers.clone(),
+		spawner: &task_manager.spawn_essential_handle(),
+		can_author_with: sp_consensus::CanAuthorWithNativeVersion::new(client.executor().clone()),
+		slot_duration: sc_consensus_aura::slot_duration(&*client)?,
+		registry: config.prometheus_registry(),
+		check_for_equivocation: Default::default(),
+		telemetry: telemetry.as_ref().map(|x| x.handle()),
+	})?;
 
 	Ok(sc_service::PartialComponents {
 		client,
@@ -119,7 +146,7 @@ pub fn new_partial(
 		select_chain,
 		transaction_pool,
 		inherent_data_providers,
-		other: (aura_block_import, grandpa_link),
+		other: (aura_block_import, grandpa_link, telemetry),
 	})
 }
 
@@ -141,7 +168,7 @@ pub fn new_full(mut config: Configuration) -> Result<TaskManager, ServiceError>
 		select_chain,
 		transaction_pool,
 		inherent_data_providers,
-		other: (block_import, grandpa_link),
+		other: (block_import, grandpa_link, mut telemetry),
 	} = new_partial(&config)?;
 
 	if let Some(url) = &config.keystore_remote {
@@ -173,13 +200,7 @@ pub fn new_full(mut config: Configuration) -> Result<TaskManager, ServiceError>
 		})?;
 
 	if config.offchain_worker.enabled {
-		sc_service::build_offchain_workers(
-			&config,
-			backend.clone(),
-			task_manager.spawn_handle(),
-			client.clone(),
-			network.clone(),
-		);
+		sc_service::build_offchain_workers(&config, task_manager.spawn_handle(), client.clone(), network.clone());
 	}
 
 	let role = config.role.clone();
@@ -265,7 +286,7 @@ pub fn new_full(mut config: Configuration) -> Result<TaskManager, ServiceError>
 		})
 	};
 
-	let (_rpc_handlers, telemetry_connection_notifier) = sc_service::spawn_tasks(sc_service::SpawnTasksParams {
+	let _rpc_handlers = sc_service::spawn_tasks(sc_service::SpawnTasksParams {
 		network: network.clone(),
 		client: client.clone(),
 		keystore: keystore_container.sync_keystore(),
@@ -278,32 +299,35 @@ pub fn new_full(mut config: Configuration) -> Result<TaskManager, ServiceError>
 		network_status_sinks,
 		system_rpc_tx,
 		config,
-		telemetry_span: None,
+		telemetry: telemetry.as_mut(),
 	})?;
 
 	if role.is_authority() {
-		let proposer = sc_basic_authorship::ProposerFactory::new(
+		let proposer_factory = sc_basic_authorship::ProposerFactory::new(
 			task_manager.spawn_handle(),
 			client.clone(),
 			transaction_pool,
 			prometheus_registry.as_ref(),
+			telemetry.as_ref().map(|x| x.handle()),
 		);
 
 		let can_author_with = sp_consensus::CanAuthorWithNativeVersion::new(client.executor().clone());
 
-		let aura = sc_consensus_aura::start_aura::<_, _, _, _, _, AuraPair, _, _, _, _>(
-			sc_consensus_aura::slot_duration(&*client)?,
-			client.clone(),
+		let aura = sc_consensus_aura::start_aura::<AuraPair, _, _, _, _, _, _, _, _, _>(StartAuraParams {
+			slot_duration: sc_consensus_aura::slot_duration(&*client)?,
+			client: client.clone(),
 			select_chain,
 			block_import,
-			proposer,
-			network.clone(),
+			proposer_factory,
 			inherent_data_providers,
 			force_authoring,
 			backoff_authoring_blocks,
-			keystore_container.sync_keystore(),
+			keystore: keystore_container.sync_keystore(),
 			can_author_with,
-		)?;
+			sync_oracle: network.clone(),
+			block_proposal_slot_portion: SlotProportion::new(2f32 / 3f32),
+			telemetry: telemetry.as_ref().map(|x| x.handle()),
+		})?;
 
 		// the AURA authoring task is considered essential, i.e. if it
 		// fails we take down the service with it.
@@ -326,6 +350,7 @@ pub fn new_full(mut config: Configuration) -> Result<TaskManager, ServiceError>
 		observer_enabled: false,
 		keystore,
 		is_authority: role.is_authority(),
+		telemetry: telemetry.as_ref().map(|x| x.handle()),
 	};
 
 	if enable_grandpa {
@@ -339,10 +364,10 @@ pub fn new_full(mut config: Configuration) -> Result<TaskManager, ServiceError>
 			config: grandpa_config,
 			link: grandpa_link,
 			network,
-			telemetry_on_connect: telemetry_connection_notifier.map(|x| x.on_connect_stream()),
 			voting_rule: sc_finality_grandpa::VotingRulesBuilder::default().build(),
 			prometheus_registry,
 			shared_voter_state: SharedVoterState::empty(),
+			telemetry: telemetry.as_ref().map(|x| x.handle()),
 		};
 
 		// the GRANDPA voter task is considered infallible, i.e.
@@ -358,8 +383,27 @@ pub fn new_full(mut config: Configuration) -> Result<TaskManager, ServiceError>
 
 /// Builds a new service for a light client.
 pub fn new_light(mut config: Configuration) -> Result<TaskManager, ServiceError> {
+	let telemetry = config
+		.telemetry_endpoints
+		.clone()
+		.filter(|x| !x.is_empty())
+		.map(|endpoints| -> Result<_, sc_telemetry::Error> {
+			let worker = TelemetryWorker::new(16)?;
+			let telemetry = worker.handle().new_telemetry(endpoints);
+			Ok((worker, telemetry))
+		})
+		.transpose()?;
+
 	let (client, backend, keystore_container, mut task_manager, on_demand) =
-		sc_service::new_light_parts::<Block, RuntimeApi, Executor>(&config)?;
+		sc_service::new_light_parts::<Block, RuntimeApi, Executor>(
+			&config,
+			telemetry.as_ref().map(|(_, telemetry)| telemetry.handle()),
+		)?;
+
+	let mut telemetry = telemetry.map(|(worker, telemetry)| {
+		task_manager.spawn_handle().spawn("telemetry", worker.run());
+		telemetry
+	});
 
 	config
 		.network
@@ -376,22 +420,28 @@ pub fn new_light(mut config: Configuration) -> Result<TaskManager, ServiceError>
 		on_demand.clone(),
 	));
 
-	let (grandpa_block_import, _) =
-		sc_finality_grandpa::block_import(client.clone(), &(client.clone() as Arc<_>), select_chain)?;
+	let (grandpa_block_import, _) = sc_finality_grandpa::block_import(
+		client.clone(),
+		&(client.clone() as Arc<_>),
+		select_chain,
+		telemetry.as_ref().map(|x| x.handle()),
+	)?;
 
 	let aura_block_import =
 		sc_consensus_aura::AuraBlockImport::<_, _, _, AuraPair>::new(grandpa_block_import.clone(), client.clone());
 
-	let import_queue = sc_consensus_aura::import_queue::<_, _, _, AuraPair, _, _>(
-		sc_consensus_aura::slot_duration(&*client)?,
-		aura_block_import,
-		Some(Box::new(grandpa_block_import)),
-		client.clone(),
-		InherentDataProviders::new(),
-		&task_manager.spawn_essential_handle(),
-		config.prometheus_registry(),
-		sp_consensus::NeverCanAuthor,
-	)?;
+	let import_queue = sc_consensus_aura::import_queue::<AuraPair, _, _, _, _, _>(ImportQueueParams {
+		block_import: aura_block_import,
+		justification_import: Some(Box::new(grandpa_block_import)),
+		client: client.clone(),
+		inherent_data_providers: InherentDataProviders::new(),
+		spawner: &task_manager.spawn_essential_handle(),
+		can_author_with: sp_consensus::NeverCanAuthor,
+		slot_duration: sc_consensus_aura::slot_duration(&*client)?,
+		registry: config.prometheus_registry(),
+		check_for_equivocation: Default::default(),
+		telemetry: telemetry.as_ref().map(|x| x.handle()),
+	})?;
 
 	let (network, network_status_sinks, system_rpc_tx, network_starter) =
 		sc_service::build_network(sc_service::BuildNetworkParams {
@@ -405,13 +455,7 @@ pub fn new_light(mut config: Configuration) -> Result<TaskManager, ServiceError>
 		})?;
 
 	if config.offchain_worker.enabled {
-		sc_service::build_offchain_workers(
-			&config,
-			backend.clone(),
-			task_manager.spawn_handle(),
-			client.clone(),
-			network.clone(),
-		);
+		sc_service::build_offchain_workers(&config, task_manager.spawn_handle(), client.clone(), network.clone());
 	}
 
 	sc_service::spawn_tasks(sc_service::SpawnTasksParams {
@@ -427,7 +471,7 @@ pub fn new_light(mut config: Configuration) -> Result<TaskManager, ServiceError>
 		network,
 		network_status_sinks,
 		system_rpc_tx,
-		telemetry_span: None,
+		telemetry: telemetry.as_mut(),
 	})?;
 
 	network_starter.start_network();

bridges/bin/millau/runtime/src/lib.rs

@@ -201,6 +201,8 @@ impl frame_system::Config for Runtime {
 	type DbWeight = DbWeight;
 	/// The designated SS58 prefix of this chain.
 	type SS58Prefix = SS58Prefix;
+	/// The set code logic, just the default since we're not a parachain.
+	type OnSetCode = ();
 }
 
 impl pallet_aura::Config for Runtime {
@@ -292,7 +294,7 @@ impl pallet_session::Config for Runtime {
 	type ValidatorIdOf = ();
 	type ShouldEndSession = pallet_session::PeriodicSessions<Period, Offset>;
 	type NextSessionRotation = pallet_session::PeriodicSessions<Period, Offset>;
-	type SessionManager = pallet_shift_session_manager::Module<Runtime>;
+	type SessionManager = pallet_shift_session_manager::Pallet<Runtime>;
 	type SessionHandler = <SessionKeys as OpaqueKeys>::KeyTypeIdProviders;
 	type Keys = SessionKeys;
 	type DisabledValidatorsThreshold = ();
@@ -363,7 +365,7 @@ impl pallet_bridge_messages::Config for Runtime {
 	type LaneMessageVerifier = crate::rialto_messages::ToRialtoMessageVerifier;
 	type MessageDeliveryAndDispatchPayment = pallet_bridge_messages::instant_payments::InstantCurrencyPayments<
 		Runtime,
-		pallet_balances::Module<Runtime>,
+		pallet_balances::Pallet<Runtime>,
 		GetDeliveryConfirmationTransactionFee,
 		RootAccountForPayments,
 	>;
@@ -378,20 +380,20 @@ construct_runtime!(
 		NodeBlock = opaque::Block,
 		UncheckedExtrinsic = UncheckedExtrinsic
 	{
-		BridgeRialtoMessages: pallet_bridge_messages::{Module, Call, Storage, Event<T>},
-		BridgeDispatch: pallet_bridge_dispatch::{Module, Event<T>},
-		BridgeRialtoGrandpa: pallet_bridge_grandpa::{Module, Call, Storage},
-		BridgeWestendGrandpa: pallet_bridge_grandpa::<Instance1>::{Module, Call, Config<T>, Storage},
-		System: frame_system::{Module, Call, Config, Storage, Event<T>},
-		RandomnessCollectiveFlip: pallet_randomness_collective_flip::{Module, Call, Storage},
-		Timestamp: pallet_timestamp::{Module, Call, Storage, Inherent},
-		Aura: pallet_aura::{Module, Config<T>},
-		Grandpa: pallet_grandpa::{Module, Call, Storage, Config, Event},
-		Balances: pallet_balances::{Module, Call, Storage, Config<T>, Event<T>},
-		TransactionPayment: pallet_transaction_payment::{Module, Storage},
-		Sudo: pallet_sudo::{Module, Call, Config<T>, Storage, Event<T>},
-		Session: pallet_session::{Module, Call, Storage, Event, Config<T>},
-		ShiftSessionManager: pallet_shift_session_manager::{Module},
+		BridgeRialtoMessages: pallet_bridge_messages::{Pallet, Call, Storage, Event<T>},
+		BridgeDispatch: pallet_bridge_dispatch::{Pallet, Event<T>},
+		BridgeRialtoGrandpa: pallet_bridge_grandpa::{Pallet, Call, Storage},
+		BridgeWestendGrandpa: pallet_bridge_grandpa::<Instance1>::{Pallet, Call, Config<T>, Storage},
+		System: frame_system::{Pallet, Call, Config, Storage, Event<T>},
+		RandomnessCollectiveFlip: pallet_randomness_collective_flip::{Pallet, Call, Storage},
+		Timestamp: pallet_timestamp::{Pallet, Call, Storage, Inherent},
+		Aura: pallet_aura::{Pallet, Config<T>},
+		Grandpa: pallet_grandpa::{Pallet, Call, Storage, Config, Event},
+		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
+		TransactionPayment: pallet_transaction_payment::{Pallet, Storage},
+		Sudo: pallet_sudo::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Session: pallet_session::{Pallet, Call, Storage, Event, Config<T>},
+		ShiftSessionManager: pallet_shift_session_manager::{Pallet},
 	}
 );
 
@@ -423,7 +425,7 @@ pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<Address, Call, Signatu
 pub type CheckedExtrinsic = generic::CheckedExtrinsic<AccountId, Call, SignedExtra>;
 /// Executive: handles dispatch to the various modules.
 pub type Executive =
-	frame_executive::Executive<Runtime, Block, frame_system::ChainContext<Runtime>, Runtime, AllModules>;
+	frame_executive::Executive<Runtime, Block, frame_system::ChainContext<Runtime>, Runtime, AllPallets>;
 
 impl_runtime_apis! {
 	impl sp_api::Core<Block> for Runtime {
@@ -467,7 +469,7 @@ impl_runtime_apis! {
 		}
 
 		fn random_seed() -> <Block as BlockT>::Hash {
-			RandomnessCollectiveFlip::random_seed().0.into()
+			RandomnessCollectiveFlip::random_seed().0
 		}
 	}
 
@@ -493,8 +495,8 @@ impl_runtime_apis! {
 	}
 
 	impl sp_consensus_aura::AuraApi<Block, AuraId> for Runtime {
-		fn slot_duration() -> u64 {
-			Aura::slot_duration()
+		fn slot_duration() -> sp_consensus_aura::SlotDuration {
+			sp_consensus_aura::SlotDuration::from_millis(Aura::slot_duration())
 		}
 
 		fn authorities() -> Vec<AuraId> {

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

@@ -122,7 +122,7 @@ impl Alternative {
 							get_account_id_from_seed::<sr25519::Public>("Ferdie//stash"),
 							get_account_id_from_seed::<sr25519::Public>("George//stash"),
 							get_account_id_from_seed::<sr25519::Public>("Harry//stash"),
-							pallet_bridge_messages::Module::<
+							pallet_bridge_messages::Pallet::<
 								rialto_runtime::Runtime,
 								pallet_bridge_messages::DefaultInstance,
 							>::relayer_fund_account_id(),
@@ -154,28 +154,28 @@ fn testnet_genesis(
 	_enable_println: bool,
 ) -> GenesisConfig {
 	GenesisConfig {
-		frame_system: Some(SystemConfig {
+		frame_system: SystemConfig {
 			code: WASM_BINARY.to_vec(),
 			changes_trie_config: Default::default(),
-		}),
-		pallet_balances: Some(BalancesConfig {
+		},
+		pallet_balances: BalancesConfig {
 			balances: endowed_accounts.iter().cloned().map(|k| (k, 1 << 50)).collect(),
-		}),
-		pallet_aura: Some(AuraConfig {
+		},
+		pallet_aura: AuraConfig {
 			authorities: Vec::new(),
-		}),
-		pallet_bridge_eth_poa_Instance1: Some(load_rialto_poa_bridge_config()),
-		pallet_bridge_eth_poa_Instance2: Some(load_kovan_bridge_config()),
-		pallet_grandpa: Some(GrandpaConfig {
+		},
+		pallet_bridge_eth_poa_Instance1: load_rialto_poa_bridge_config(),
+		pallet_bridge_eth_poa_Instance2: load_kovan_bridge_config(),
+		pallet_grandpa: GrandpaConfig {
 			authorities: Vec::new(),
-		}),
-		pallet_sudo: Some(SudoConfig { key: root_key }),
-		pallet_session: Some(SessionConfig {
+		},
+		pallet_sudo: SudoConfig { key: root_key },
+		pallet_session: SessionConfig {
 			keys: initial_authorities
 				.iter()
 				.map(|x| (x.0.clone(), x.0.clone(), session_keys(x.1.clone(), x.2.clone())))
 				.collect::<Vec<_>>(),
-		}),
+		},
 	}
 }
 

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

@@ -30,11 +30,13 @@
 
 use rialto_runtime::{self, opaque::Block, RuntimeApi};
 use sc_client_api::{ExecutorProvider, RemoteBackend};
+use sc_consensus_aura::{ImportQueueParams, SlotProportion, StartAuraParams};
 use sc_executor::native_executor_instance;
 pub use sc_executor::NativeExecutor;
 use sc_finality_grandpa::SharedVoterState;
 use sc_keystore::LocalKeystore;
 use sc_service::{error::Error as ServiceError, Configuration, TaskManager};
+use sc_telemetry::{Telemetry, TelemetryWorker};
 use sp_consensus_aura::sr25519::AuthorityPair as AuraPair;
 use sp_inherents::InherentDataProviders;
 use std::sync::Arc;
@@ -70,6 +72,7 @@ pub fn new_partial(
 				AuraPair,
 			>,
 			sc_finality_grandpa::LinkHalf<Block, FullClient, FullSelectChain>,
+			Option<Telemetry>,
 		),
 	>,
 	ServiceError,
@@ -77,12 +80,30 @@ pub fn new_partial(
 	if config.keystore_remote.is_some() {
 		return Err(ServiceError::Other("Remote Keystores are not supported.".to_string()));
 	}
-	let inherent_data_providers = sp_inherents::InherentDataProviders::new();
+	let inherent_data_providers = InherentDataProviders::new();
 
-	let (client, backend, keystore_container, task_manager) =
-		sc_service::new_full_parts::<Block, RuntimeApi, Executor>(&config)?;
+	let telemetry = config
+		.telemetry_endpoints
+		.clone()
+		.filter(|x| !x.is_empty())
+		.map(|endpoints| -> Result<_, sc_telemetry::Error> {
+			let worker = TelemetryWorker::new(16)?;
+			let telemetry = worker.handle().new_telemetry(endpoints);
+			Ok((worker, telemetry))
+		})
+		.transpose()?;
+
+	let (client, backend, keystore_container, task_manager) = sc_service::new_full_parts::<Block, RuntimeApi, Executor>(
+		&config,
+		telemetry.as_ref().map(|(_, telemetry)| telemetry.handle()),
+	)?;
 	let client = Arc::new(client);
 
+	let telemetry = telemetry.map(|(worker, telemetry)| {
+		task_manager.spawn_handle().spawn("telemetry", worker.run());
+		telemetry
+	});
+
 	let select_chain = sc_consensus::LongestChain::new(backend.clone());
 
 	let transaction_pool = sc_transaction_pool::BasicPool::new_full(
@@ -93,22 +114,28 @@ pub fn new_partial(
 		client.clone(),
 	);
 
-	let (grandpa_block_import, grandpa_link) =
-		sc_finality_grandpa::block_import(client.clone(), &(client.clone() as Arc<_>), select_chain.clone())?;
+	let (grandpa_block_import, grandpa_link) = sc_finality_grandpa::block_import(
+		client.clone(),
+		&(client.clone() as Arc<_>),
+		select_chain.clone(),
+		telemetry.as_ref().map(|x| x.handle()),
+	)?;
 
 	let aura_block_import =
 		sc_consensus_aura::AuraBlockImport::<_, _, _, AuraPair>::new(grandpa_block_import.clone(), client.clone());
 
-	let import_queue = sc_consensus_aura::import_queue::<_, _, _, AuraPair, _, _>(
-		sc_consensus_aura::slot_duration(&*client)?,
-		aura_block_import.clone(),
-		Some(Box::new(grandpa_block_import)),
-		client.clone(),
-		inherent_data_providers.clone(),
-		&task_manager.spawn_essential_handle(),
-		config.prometheus_registry(),
-		sp_consensus::CanAuthorWithNativeVersion::new(client.executor().clone()),
-	)?;
+	let import_queue = sc_consensus_aura::import_queue::<AuraPair, _, _, _, _, _>(ImportQueueParams {
+		block_import: aura_block_import.clone(),
+		justification_import: Some(Box::new(grandpa_block_import)),
+		client: client.clone(),
+		inherent_data_providers: inherent_data_providers.clone(),
+		spawner: &task_manager.spawn_essential_handle(),
+		can_author_with: sp_consensus::CanAuthorWithNativeVersion::new(client.executor().clone()),
+		slot_duration: sc_consensus_aura::slot_duration(&*client)?,
+		registry: config.prometheus_registry(),
+		check_for_equivocation: Default::default(),
+		telemetry: telemetry.as_ref().map(|x| x.handle()),
+	})?;
 
 	Ok(sc_service::PartialComponents {
 		client,
@@ -119,7 +146,7 @@ pub fn new_partial(
 		select_chain,
 		transaction_pool,
 		inherent_data_providers,
-		other: (aura_block_import, grandpa_link),
+		other: (aura_block_import, grandpa_link, telemetry),
 	})
 }
 
@@ -141,7 +168,7 @@ pub fn new_full(mut config: Configuration) -> Result<TaskManager, ServiceError>
 		select_chain,
 		transaction_pool,
 		inherent_data_providers,
-		other: (block_import, grandpa_link),
+		other: (block_import, grandpa_link, mut telemetry),
 	} = new_partial(&config)?;
 
 	if let Some(url) = &config.keystore_remote {
@@ -173,13 +200,7 @@ pub fn new_full(mut config: Configuration) -> Result<TaskManager, ServiceError>
 		})?;
 
 	if config.offchain_worker.enabled {
-		sc_service::build_offchain_workers(
-			&config,
-			backend.clone(),
-			task_manager.spawn_handle(),
-			client.clone(),
-			network.clone(),
-		);
+		sc_service::build_offchain_workers(&config, task_manager.spawn_handle(), client.clone(), network.clone());
 	}
 
 	let role = config.role.clone();
@@ -266,7 +287,7 @@ pub fn new_full(mut config: Configuration) -> Result<TaskManager, ServiceError>
 		})
 	};
 
-	let (_rpc_handlers, telemetry_connection_notifier) = sc_service::spawn_tasks(sc_service::SpawnTasksParams {
+	let _rpc_handlers = sc_service::spawn_tasks(sc_service::SpawnTasksParams {
 		network: network.clone(),
 		client: client.clone(),
 		keystore: keystore_container.sync_keystore(),
@@ -279,32 +300,35 @@ pub fn new_full(mut config: Configuration) -> Result<TaskManager, ServiceError>
 		network_status_sinks,
 		system_rpc_tx,
 		config,
-		telemetry_span: None,
+		telemetry: telemetry.as_mut(),
 	})?;
 
 	if role.is_authority() {
-		let proposer = sc_basic_authorship::ProposerFactory::new(
+		let proposer_factory = sc_basic_authorship::ProposerFactory::new(
 			task_manager.spawn_handle(),
 			client.clone(),
 			transaction_pool,
 			prometheus_registry.as_ref(),
+			telemetry.as_ref().map(|x| x.handle()),
 		);
 
 		let can_author_with = sp_consensus::CanAuthorWithNativeVersion::new(client.executor().clone());
 
-		let aura = sc_consensus_aura::start_aura::<_, _, _, _, _, AuraPair, _, _, _, _>(
-			sc_consensus_aura::slot_duration(&*client)?,
-			client.clone(),
+		let aura = sc_consensus_aura::start_aura::<AuraPair, _, _, _, _, _, _, _, _, _>(StartAuraParams {
+			slot_duration: sc_consensus_aura::slot_duration(&*client)?,
+			client: client.clone(),
 			select_chain,
 			block_import,
-			proposer,
-			network.clone(),
+			proposer_factory,
 			inherent_data_providers,
 			force_authoring,
 			backoff_authoring_blocks,
-			keystore_container.sync_keystore(),
+			keystore: keystore_container.sync_keystore(),
 			can_author_with,
-		)?;
+			sync_oracle: network.clone(),
+			block_proposal_slot_portion: SlotProportion::new(2f32 / 3f32),
+			telemetry: telemetry.as_ref().map(|x| x.handle()),
+		})?;
 
 		// the AURA authoring task is considered essential, i.e. if it
 		// fails we take down the service with it.
@@ -327,6 +351,7 @@ pub fn new_full(mut config: Configuration) -> Result<TaskManager, ServiceError>
 		observer_enabled: false,
 		keystore,
 		is_authority: role.is_authority(),
+		telemetry: telemetry.as_ref().map(|x| x.handle()),
 	};
 
 	if enable_grandpa {
@@ -340,10 +365,10 @@ pub fn new_full(mut config: Configuration) -> Result<TaskManager, ServiceError>
 			config: grandpa_config,
 			link: grandpa_link,
 			network,
-			telemetry_on_connect: telemetry_connection_notifier.map(|x| x.on_connect_stream()),
 			voting_rule: sc_finality_grandpa::VotingRulesBuilder::default().build(),
 			prometheus_registry,
 			shared_voter_state: SharedVoterState::empty(),
+			telemetry: telemetry.as_ref().map(|x| x.handle()),
 		};
 
 		// the GRANDPA voter task is considered infallible, i.e.
@@ -359,8 +384,27 @@ pub fn new_full(mut config: Configuration) -> Result<TaskManager, ServiceError>
 
 /// Builds a new service for a light client.
 pub fn new_light(mut config: Configuration) -> Result<TaskManager, ServiceError> {
+	let telemetry = config
+		.telemetry_endpoints
+		.clone()
+		.filter(|x| !x.is_empty())
+		.map(|endpoints| -> Result<_, sc_telemetry::Error> {
+			let worker = TelemetryWorker::new(16)?;
+			let telemetry = worker.handle().new_telemetry(endpoints);
+			Ok((worker, telemetry))
+		})
+		.transpose()?;
+
 	let (client, backend, keystore_container, mut task_manager, on_demand) =
-		sc_service::new_light_parts::<Block, RuntimeApi, Executor>(&config)?;
+		sc_service::new_light_parts::<Block, RuntimeApi, Executor>(
+			&config,
+			telemetry.as_ref().map(|(_, telemetry)| telemetry.handle()),
+		)?;
+
+	let mut telemetry = telemetry.map(|(worker, telemetry)| {
+		task_manager.spawn_handle().spawn("telemetry", worker.run());
+		telemetry
+	});
 
 	config
 		.network
@@ -377,22 +421,28 @@ pub fn new_light(mut config: Configuration) -> Result<TaskManager, ServiceError>
 		on_demand.clone(),
 	));
 
-	let (grandpa_block_import, _) =
-		sc_finality_grandpa::block_import(client.clone(), &(client.clone() as Arc<_>), select_chain)?;
+	let (grandpa_block_import, _) = sc_finality_grandpa::block_import(
+		client.clone(),
+		&(client.clone() as Arc<_>),
+		select_chain,
+		telemetry.as_ref().map(|x| x.handle()),
+	)?;
 
 	let aura_block_import =
 		sc_consensus_aura::AuraBlockImport::<_, _, _, AuraPair>::new(grandpa_block_import.clone(), client.clone());
 
-	let import_queue = sc_consensus_aura::import_queue::<_, _, _, AuraPair, _, _>(
-		sc_consensus_aura::slot_duration(&*client)?,
-		aura_block_import,
-		Some(Box::new(grandpa_block_import)),
-		client.clone(),
-		InherentDataProviders::new(),
-		&task_manager.spawn_essential_handle(),
-		config.prometheus_registry(),
-		sp_consensus::NeverCanAuthor,
-	)?;
+	let import_queue = sc_consensus_aura::import_queue::<AuraPair, _, _, _, _, _>(ImportQueueParams {
+		block_import: aura_block_import,
+		justification_import: Some(Box::new(grandpa_block_import)),
+		client: client.clone(),
+		inherent_data_providers: InherentDataProviders::new(),
+		spawner: &task_manager.spawn_essential_handle(),
+		can_author_with: sp_consensus::NeverCanAuthor,
+		slot_duration: sc_consensus_aura::slot_duration(&*client)?,
+		registry: config.prometheus_registry(),
+		check_for_equivocation: Default::default(),
+		telemetry: telemetry.as_ref().map(|x| x.handle()),
+	})?;
 
 	let (network, network_status_sinks, system_rpc_tx, network_starter) =
 		sc_service::build_network(sc_service::BuildNetworkParams {
@@ -406,13 +456,7 @@ pub fn new_light(mut config: Configuration) -> Result<TaskManager, ServiceError>
 		})?;
 
 	if config.offchain_worker.enabled {
-		sc_service::build_offchain_workers(
-			&config,
-			backend.clone(),
-			task_manager.spawn_handle(),
-			client.clone(),
-			network.clone(),
-		);
+		sc_service::build_offchain_workers(&config, task_manager.spawn_handle(), client.clone(), network.clone());
 	}
 
 	sc_service::spawn_tasks(sc_service::SpawnTasksParams {
@@ -428,7 +472,7 @@ pub fn new_light(mut config: Configuration) -> Result<TaskManager, ServiceError>
 		network,
 		network_status_sinks,
 		system_rpc_tx,
-		telemetry_span: None,
+		telemetry: telemetry.as_mut(),
 	})?;
 
 	network_starter.start_network();

bridges/bin/rialto/runtime/src/lib.rs

@@ -208,6 +208,8 @@ impl frame_system::Config for Runtime {
 	type DbWeight = DbWeight;
 	/// The designated SS58 prefix of this chain.
 	type SS58Prefix = SS58Prefix;
+	/// The set code logic, just the default since we're not a parachain.
+	type OnSetCode = ();
 }
 
 impl pallet_aura::Config for Runtime {
@@ -277,7 +279,7 @@ impl bp_currency_exchange::DepositInto for DepositInto {
 	fn deposit_into(recipient: Self::Recipient, amount: Self::Amount) -> bp_currency_exchange::Result<()> {
 		// let balances module make all checks for us (it won't allow depositing lower than existential
 		// deposit, balance overflow, ...)
-		let deposited = <pallet_balances::Module<Runtime> as Currency<AccountId>>::deposit_creating(&recipient, amount);
+		let deposited = <pallet_balances::Pallet<Runtime> as Currency<AccountId>>::deposit_creating(&recipient, amount);
 
 		// I'm dropping deposited here explicitly to illustrate the fact that it'll update `TotalIssuance`
 		// on drop
@@ -398,7 +400,7 @@ impl pallet_session::Config for Runtime {
 	type ValidatorIdOf = ();
 	type ShouldEndSession = pallet_session::PeriodicSessions<Period, Offset>;
 	type NextSessionRotation = pallet_session::PeriodicSessions<Period, Offset>;
-	type SessionManager = pallet_shift_session_manager::Module<Runtime>;
+	type SessionManager = pallet_shift_session_manager::Pallet<Runtime>;
 	type SessionHandler = <SessionKeys as OpaqueKeys>::KeyTypeIdProviders;
 	type Keys = SessionKeys;
 	type DisabledValidatorsThreshold = ();
@@ -456,7 +458,7 @@ impl pallet_bridge_messages::Config for Runtime {
 	type LaneMessageVerifier = crate::millau_messages::ToMillauMessageVerifier;
 	type MessageDeliveryAndDispatchPayment = pallet_bridge_messages::instant_payments::InstantCurrencyPayments<
 		Runtime,
-		pallet_balances::Module<Runtime>,
+		pallet_balances::Pallet<Runtime>,
 		GetDeliveryConfirmationTransactionFee,
 		RootAccountForPayments,
 	>;
@@ -471,23 +473,23 @@ construct_runtime!(
 		NodeBlock = opaque::Block,
 		UncheckedExtrinsic = UncheckedExtrinsic
 	{
-		BridgeRialtoPoA: pallet_bridge_eth_poa::<Instance1>::{Module, Call, Config, Storage, ValidateUnsigned},
-		BridgeKovan: pallet_bridge_eth_poa::<Instance2>::{Module, Call, Config, Storage, ValidateUnsigned},
-		BridgeRialtoCurrencyExchange: pallet_bridge_currency_exchange::<Instance1>::{Module, Call},
-		BridgeKovanCurrencyExchange: pallet_bridge_currency_exchange::<Instance2>::{Module, Call},
-		BridgeMillauGrandpa: pallet_bridge_grandpa::{Module, Call, Storage},
-		BridgeDispatch: pallet_bridge_dispatch::{Module, Event<T>},
-		BridgeMillauMessages: pallet_bridge_messages::{Module, Call, Storage, Event<T>},
-		System: frame_system::{Module, Call, Config, Storage, Event<T>},
-		RandomnessCollectiveFlip: pallet_randomness_collective_flip::{Module, Call, Storage},
-		Timestamp: pallet_timestamp::{Module, Call, Storage, Inherent},
-		Aura: pallet_aura::{Module, Config<T>},
-		Grandpa: pallet_grandpa::{Module, Call, Storage, Config, Event},
-		Balances: pallet_balances::{Module, Call, Storage, Config<T>, Event<T>},
-		TransactionPayment: pallet_transaction_payment::{Module, Storage},
-		Sudo: pallet_sudo::{Module, Call, Config<T>, Storage, Event<T>},
-		Session: pallet_session::{Module, Call, Storage, Event, Config<T>},
-		ShiftSessionManager: pallet_shift_session_manager::{Module},
+		BridgeRialtoPoA: pallet_bridge_eth_poa::<Instance1>::{Pallet, Call, Config, Storage, ValidateUnsigned},
+		BridgeKovan: pallet_bridge_eth_poa::<Instance2>::{Pallet, Call, Config, Storage, ValidateUnsigned},
+		BridgeRialtoCurrencyExchange: pallet_bridge_currency_exchange::<Instance1>::{Pallet, Call},
+		BridgeKovanCurrencyExchange: pallet_bridge_currency_exchange::<Instance2>::{Pallet, Call},
+		BridgeMillauGrandpa: pallet_bridge_grandpa::{Pallet, Call, Storage},
+		BridgeDispatch: pallet_bridge_dispatch::{Pallet, Event<T>},
+		BridgeMillauMessages: pallet_bridge_messages::{Pallet, Call, Storage, Event<T>},
+		System: frame_system::{Pallet, Call, Config, Storage, Event<T>},
+		RandomnessCollectiveFlip: pallet_randomness_collective_flip::{Pallet, Call, Storage},
+		Timestamp: pallet_timestamp::{Pallet, Call, Storage, Inherent},
+		Aura: pallet_aura::{Pallet, Config<T>},
+		Grandpa: pallet_grandpa::{Pallet, Call, Storage, Config, Event},
+		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
+		TransactionPayment: pallet_transaction_payment::{Pallet, Storage},
+		Sudo: pallet_sudo::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Session: pallet_session::{Pallet, Call, Storage, Event, Config<T>},
+		ShiftSessionManager: pallet_shift_session_manager::{Pallet},
 	}
 );
 
@@ -519,7 +521,7 @@ pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<Address, Call, Signatu
 pub type CheckedExtrinsic = generic::CheckedExtrinsic<AccountId, Call, SignedExtra>;
 /// Executive: handles dispatch to the various modules.
 pub type Executive =
-	frame_executive::Executive<Runtime, Block, frame_system::ChainContext<Runtime>, Runtime, AllModules>;
+	frame_executive::Executive<Runtime, Block, frame_system::ChainContext<Runtime>, Runtime, AllPallets>;
 
 impl_runtime_apis! {
 	impl sp_api::Core<Block> for Runtime {
@@ -563,7 +565,7 @@ impl_runtime_apis! {
 		}
 
 		fn random_seed() -> <Block as BlockT>::Hash {
-			RandomnessCollectiveFlip::random_seed().0.into()
+			RandomnessCollectiveFlip::random_seed().0
 		}
 	}
 
@@ -652,8 +654,8 @@ impl_runtime_apis! {
 	}
 
 	impl sp_consensus_aura::AuraApi<Block, AuraId> for Runtime {
-		fn slot_duration() -> u64 {
-			Aura::slot_duration()
+		fn slot_duration() -> sp_consensus_aura::SlotDuration {
+			sp_consensus_aura::SlotDuration::from_millis(Aura::slot_duration())
 		}
 
 		fn authorities() -> Vec<AuraId> {
@@ -789,7 +791,7 @@ impl_runtime_apis! {
 			let params = (&config, &whitelist);
 
 			use pallet_bridge_currency_exchange::benchmarking::{
-				Module as BridgeCurrencyExchangeBench,
+				Pallet as BridgeCurrencyExchangeBench,
 				Config as BridgeCurrencyExchangeConfig,
 				ProofParams as BridgeCurrencyExchangeProofParams,
 			};
@@ -831,7 +833,7 @@ impl_runtime_apis! {
 			use crate::millau_messages::{ToMillauMessagePayload, WithMillauMessageBridge};
 			use bridge_runtime_common::messages;
 			use pallet_bridge_messages::benchmarking::{
-				Module as MessagesBench,
+				Pallet as MessagesBench,
 				Config as MessagesConfig,
 				MessageDeliveryProofParams,
 				MessageParams,
@@ -849,11 +851,11 @@ impl_runtime_apis! {
 				}
 
 				fn account_balance(account: &Self::AccountId) -> Self::OutboundMessageFee {
-					pallet_balances::Module::<Runtime>::free_balance(account)
+					pallet_balances::Pallet::<Runtime>::free_balance(account)
 				}
 
 				fn endow_account(account: &Self::AccountId) {
-					pallet_balances::Module::<Runtime>::make_free_balance_be(
+					pallet_balances::Pallet::<Runtime>::make_free_balance_be(
 						account,
 						Balance::MAX / 100,
 					);
@@ -1033,7 +1035,7 @@ mod tests {
 		ext.execute_with(|| {
 			// initially issuance is zero
 			assert_eq!(
-				<pallet_balances::Module<Runtime> as Currency<AccountId>>::total_issuance(),
+				<pallet_balances::Pallet<Runtime> as Currency<AccountId>>::total_issuance(),
 				0,
 			);
 
@@ -1041,14 +1043,14 @@ mod tests {
 			let account: AccountId = [1u8; 32].into();
 			let initial_amount = ExistentialDeposit::get();
 			let deposited =
-				<pallet_balances::Module<Runtime> as Currency<AccountId>>::deposit_creating(&account, initial_amount);
+				<pallet_balances::Pallet<Runtime> as Currency<AccountId>>::deposit_creating(&account, initial_amount);
 			drop(deposited);
 			assert_eq!(
-				<pallet_balances::Module<Runtime> as Currency<AccountId>>::total_issuance(),
+				<pallet_balances::Pallet<Runtime> as Currency<AccountId>>::total_issuance(),
 				initial_amount,
 			);
 			assert_eq!(
-				<pallet_balances::Module<Runtime> as Currency<AccountId>>::free_balance(&account),
+				<pallet_balances::Pallet<Runtime> as Currency<AccountId>>::free_balance(&account),
 				initial_amount,
 			);
 
@@ -1057,7 +1059,7 @@ mod tests {
 
 			// check that total issuance has changed by `run_deposit_into_test`
 			assert_eq!(
-				<pallet_balances::Module<Runtime> as Currency<AccountId>>::total_issuance(),
+				<pallet_balances::Pallet<Runtime> as Currency<AccountId>>::total_issuance(),
 				initial_amount + total_issuance_change,
 			);
 		});
@@ -1101,7 +1103,7 @@ mod tests {
 	fn deposit_into_existing_account_works() {
 		run_deposit_into_test(|existing_account| {
 			let initial_amount =
-				<pallet_balances::Module<Runtime> as Currency<AccountId>>::free_balance(&existing_account);
+				<pallet_balances::Pallet<Runtime> as Currency<AccountId>>::free_balance(&existing_account);
 			let additional_amount = 10_000;
 			<Runtime as pallet_bridge_currency_exchange::Config<KovanCurrencyExchange>>::DepositInto::deposit_into(
 				existing_account.clone(),
@@ -1109,7 +1111,7 @@ mod tests {
 			)
 			.unwrap();
 			assert_eq!(
-				<pallet_balances::Module<Runtime> as Currency<AccountId>>::free_balance(&existing_account),
+				<pallet_balances::Pallet<Runtime> as Currency<AccountId>>::free_balance(&existing_account),
 				initial_amount + additional_amount,
 			);
 			additional_amount
@@ -1128,7 +1130,7 @@ mod tests {
 			)
 			.unwrap();
 			assert_eq!(
-				<pallet_balances::Module<Runtime> as Currency<AccountId>>::free_balance(&new_account),
+				<pallet_balances::Pallet<Runtime> as Currency<AccountId>>::free_balance(&new_account),
 				initial_amount + additional_amount,
 			);
 			additional_amount

bridges/bin/runtime-common/src/messages.rs

@@ -365,7 +365,7 @@ pub mod source {
 			storage_proof,
 			lane,
 		} = proof;
-		pallet_bridge_grandpa::Module::<ThisRuntime>::parse_finalized_storage_proof(
+		pallet_bridge_grandpa::Pallet::<ThisRuntime>::parse_finalized_storage_proof(
 			bridged_header_hash.into(),
 			StorageProof::new(storage_proof),
 			|storage| {
@@ -468,7 +468,7 @@ pub mod target {
 		ThisRuntime: pallet_bridge_dispatch::Config<ThisDispatchInstance, MessageId = (LaneId, MessageNonce)>,
 		<ThisRuntime as pallet_bridge_dispatch::Config<ThisDispatchInstance>>::Event:
 			From<pallet_bridge_dispatch::RawEvent<(LaneId, MessageNonce), ThisDispatchInstance>>,
-		pallet_bridge_dispatch::Module<ThisRuntime, ThisDispatchInstance>:
+		pallet_bridge_dispatch::Pallet<ThisRuntime, ThisDispatchInstance>:
 			bp_message_dispatch::MessageDispatch<(LaneId, MessageNonce), Message = FromBridgedChainMessagePayload<B>>,
 	{
 		type DispatchPayload = FromBridgedChainMessagePayload<B>;
@@ -481,7 +481,7 @@ pub mod target {
 
 		fn dispatch(message: DispatchMessage<Self::DispatchPayload, BalanceOf<BridgedChain<B>>>) {
 			let message_id = (message.key.lane_id, message.key.nonce);
-			pallet_bridge_dispatch::Module::<ThisRuntime, ThisDispatchInstance>::dispatch(
+			pallet_bridge_dispatch::Pallet::<ThisRuntime, ThisDispatchInstance>::dispatch(
 				B::INSTANCE,
 				message_id,
 				message.data.payload.map_err(drop),
@@ -517,7 +517,7 @@ pub mod target {
 			proof,
 			messages_count,
 			|bridged_header_hash, bridged_storage_proof| {
-				pallet_bridge_grandpa::Module::<ThisRuntime>::parse_finalized_storage_proof(
+				pallet_bridge_grandpa::Pallet::<ThisRuntime>::parse_finalized_storage_proof(
 					bridged_header_hash.into(),
 					StorageProof::new(bridged_storage_proof),
 					|storage_adapter| storage_adapter,

bridges/modules/currency-exchange/src/benchmarking.rs

@@ -19,7 +19,7 @@
 //! before invoking module calls.
 
 use super::{
-	Call, Config as CurrencyExchangeConfig, InclusionProofVerifier, Instance, Module as CurrencyExchangeModule,
+	Call, Config as CurrencyExchangeConfig, InclusionProofVerifier, Instance, Pallet as CurrencyExchangePallet,
 };
 use sp_std::prelude::*;
 
@@ -30,8 +30,8 @@ const SEED: u32 = 0;
 const WORST_TX_SIZE_FACTOR: u32 = 1000;
 const WORST_PROOF_SIZE_FACTOR: u32 = 1000;
 
-/// Module we're benchmarking here.
-pub struct Module<T: Config<I>, I: Instance>(CurrencyExchangeModule<T, I>);
+/// Pallet we're benchmarking here.
+pub struct Pallet<T: Config<I>, I: Instance>(CurrencyExchangePallet<T, I>);
 
 /// Proof benchmarking parameters.
 pub struct ProofParams<Recipient> {

bridges/modules/currency-exchange/src/lib.rs

@@ -61,7 +61,7 @@ pub trait Config<I = DefaultInstance>: frame_system::Config {
 }
 
 decl_error! {
-	pub enum Error for Module<T: Config<I>, I: Instance> {
+	pub enum Error for Pallet<T: Config<I>, I: Instance> {
 		/// Invalid peer blockchain transaction provided.
 		InvalidTransaction,
 		/// Peer transaction has invalid amount.
@@ -125,13 +125,13 @@ decl_module! {
 }
 
 decl_storage! {
-	trait Store for Module<T: Config<I>, I: Instance = DefaultInstance> as Bridge {
+	trait Store for Pallet<T: Config<I>, I: Instance = DefaultInstance> as Bridge {
 		/// All transfers that have already been claimed.
 		Transfers: map hasher(blake2_128_concat) <T::PeerMaybeLockFundsTransaction as MaybeLockFundsTransaction>::Id => ();
 	}
 }
 
-impl<T: Config<I>, I: Instance> Module<T, I> {
+impl<T: Config<I>, I: Instance> Pallet<T, I> {
 	/// Returns true if currency exchange module is able to import given transaction proof in
 	/// its current state.
 	pub fn filter_transaction_proof(
@@ -326,8 +326,8 @@ mod tests {
 			NodeBlock = Block,
 			UncheckedExtrinsic = UncheckedExtrinsic,
 		{
-			System: frame_system::{Module, Call, Config, Storage, Event<T>},
-			Exchange: pallet_bridge_currency_exchange::{Module},
+			System: frame_system::{Pallet, Call, Config, Storage, Event<T>},
+			Exchange: pallet_bridge_currency_exchange::{Pallet},
 		}
 	}
 
@@ -361,6 +361,7 @@ mod tests {
 		type BlockLength = ();
 		type DbWeight = ();
 		type SS58Prefix = ();
+		type OnSetCode = ();
 	}
 
 	impl Config for TestRuntime {

bridges/modules/dispatch/src/lib.rs

@@ -153,7 +153,7 @@ pub trait Config<I = DefaultInstance>: frame_system::Config {
 }
 
 decl_storage! {
-	trait Store for Module<T: Config<I>, I: Instance = DefaultInstance> as Dispatch {}
+	trait Store for Pallet<T: Config<I>, I: Instance = DefaultInstance> as Dispatch {}
 }
 
 decl_event!(
@@ -189,7 +189,7 @@ decl_module! {
 	}
 }
 
-impl<T: Config<I>, I: Instance> MessageDispatch<T::MessageId> for Module<T, I> {
+impl<T: Config<I>, I: Instance> MessageDispatch<T::MessageId> for Pallet<T, I> {
 	type Message =
 		MessagePayload<T::SourceChainAccountId, T::TargetChainAccountPublic, T::TargetChainSignature, T::EncodedCall>;
 
@@ -455,8 +455,8 @@ mod tests {
 			NodeBlock = Block,
 			UncheckedExtrinsic = UncheckedExtrinsic,
 		{
-			System: frame_system::{Module, Call, Config, Storage, Event<T>},
-			Dispatch: call_dispatch::{Module, Call, Event<T>},
+			System: frame_system::{Pallet, Call, Config, Storage, Event<T>},
+			Dispatch: call_dispatch::{Pallet, Call, Event<T>},
 		}
 	}
 
@@ -490,6 +490,7 @@ mod tests {
 		type BlockLength = ();
 		type DbWeight = ();
 		type SS58Prefix = ();
+		type OnSetCode = ();
 	}
 
 	impl Config for TestRuntime {
@@ -534,7 +535,7 @@ mod tests {
 	fn prepare_message(
 		origin: CallOrigin<AccountId, TestAccountPublic, TestSignature>,
 		call: Call,
-	) -> <Module<TestRuntime> as MessageDispatch<<TestRuntime as Config>::MessageId>>::Message {
+	) -> <Pallet<TestRuntime> as MessageDispatch<<TestRuntime as Config>::MessageId>>::Message {
 		MessagePayload {
 			spec_version: TEST_SPEC_VERSION,
 			weight: TEST_WEIGHT,
@@ -545,20 +546,20 @@ mod tests {
 
 	fn prepare_root_message(
 		call: Call,
-	) -> <Module<TestRuntime> as MessageDispatch<<TestRuntime as Config>::MessageId>>::Message {
+	) -> <Pallet<TestRuntime> as MessageDispatch<<TestRuntime as Config>::MessageId>>::Message {
 		prepare_message(CallOrigin::SourceRoot, call)
 	}
 
 	fn prepare_target_message(
 		call: Call,
-	) -> <Module<TestRuntime> as MessageDispatch<<TestRuntime as Config>::MessageId>>::Message {
+	) -> <Pallet<TestRuntime> as MessageDispatch<<TestRuntime as Config>::MessageId>>::Message {
 		let origin = CallOrigin::TargetAccount(1, TestAccountPublic(1), TestSignature(1));
 		prepare_message(origin, call)
 	}
 
 	fn prepare_source_message(
 		call: Call,
-	) -> <Module<TestRuntime> as MessageDispatch<<TestRuntime as Config>::MessageId>>::Message {
+	) -> <Pallet<TestRuntime> as MessageDispatch<<TestRuntime as Config>::MessageId>>::Message {
 		let origin = CallOrigin::SourceAccount(1);
 		prepare_message(origin, call)
 	}

bridges/modules/ethereum/src/lib.rs

@@ -313,7 +313,7 @@ pub trait PruningStrategy: Default {
 	/// Every value that is returned from this function, must be greater or equal to the
 	/// previous value. Otherwise it will be ignored (we can't revert pruning).
 	///
-	/// Module may prune both finalized and unfinalized blocks. But it can't give any
+	/// Pallet may prune both finalized and unfinalized blocks. But it can't give any
 	/// guarantees on when it will happen. Example: if some unfinalized block at height N
 	/// has scheduled validators set change, then the module won't prune any blocks with
 	/// number >= N even if strategy allows that.
@@ -457,7 +457,7 @@ decl_module! {
 }
 
 decl_storage! {
-	trait Store for Module<T: Config<I>, I: Instance = DefaultInstance> as Bridge {
+	trait Store for Pallet<T: Config<I>, I: Instance = DefaultInstance> as Bridge {
 		/// Best known block.
 		BestBlock: (HeaderId, U256);
 		/// Best finalized block.
@@ -505,7 +505,7 @@ decl_storage! {
 	}
 }
 
-impl<T: Config<I>, I: Instance> Module<T, I> {
+impl<T: Config<I>, I: Instance> Pallet<T, I> {
 	/// Returns number and hash of the best block known to the bridge module.
 	/// The caller should only submit `import_header` transaction that makes
 	/// (or leads to making) other header the best one.
@@ -542,7 +542,7 @@ impl<T: Config<I>, I: Instance> Module<T, I> {
 	}
 }
 
-impl<T: Config<I>, I: Instance> frame_support::unsigned::ValidateUnsigned for Module<T, I> {
+impl<T: Config<I>, I: Instance> frame_support::unsigned::ValidateUnsigned for Pallet<T, I> {
 	type Call = Call<T, I>;
 
 	fn validate_unsigned(_source: TransactionSource, call: &Self::Call) -> TransactionValidity {

bridges/modules/ethereum/src/mock.rs

@@ -44,8 +44,8 @@ frame_support::construct_runtime! {
 		NodeBlock = Block,
 		UncheckedExtrinsic = UncheckedExtrinsic,
 	{
-		System: frame_system::{Module, Call, Config, Storage, Event<T>},
-		Ethereum: pallet_ethereum::{Module, Call},
+		System: frame_system::{Pallet, Call, Config, Storage, Event<T>},
+		Ethereum: pallet_ethereum::{Pallet, Call},
 	}
 }
 
@@ -79,6 +79,7 @@ impl frame_system::Config for TestRuntime {
 	type BlockLength = ();
 	type DbWeight = ();
 	type SS58Prefix = ();
+	type OnSetCode = ();
 }
 
 parameter_types! {

bridges/modules/grandpa/src/lib.rs

@@ -53,7 +53,7 @@ use sp_runtime::RuntimeDebug;
 #[cfg(test)]
 mod mock;
 
-/// Module containing weights for this pallet.
+/// Pallet containing weights for this pallet.
 pub mod weights;
 
 #[cfg(feature = "runtime-benchmarks")]
@@ -191,19 +191,19 @@ pub mod pallet {
 			Ok(().into())
 		}
 
-		/// Change `ModuleOwner`.
+		/// Change `PalletOwner`.
 		///
-		/// May only be called either by root, or by `ModuleOwner`.
+		/// May only be called either by root, or by `PalletOwner`.
 		#[pallet::weight((T::DbWeight::get().reads_writes(1, 1), DispatchClass::Operational))]
 		pub fn set_owner(origin: OriginFor<T>, new_owner: Option<T::AccountId>) -> DispatchResultWithPostInfo {
 			ensure_owner_or_root::<T, I>(origin)?;
 			match new_owner {
 				Some(new_owner) => {
-					ModuleOwner::<T, I>::put(&new_owner);
+					PalletOwner::<T, I>::put(&new_owner);
 					log::info!(target: "runtime::bridge-grandpa", "Setting pallet Owner to: {:?}", new_owner);
 				}
 				None => {
-					ModuleOwner::<T, I>::kill();
+					PalletOwner::<T, I>::kill();
 					log::info!(target: "runtime::bridge-grandpa", "Removed Owner of pallet.");
 				}
 			}
@@ -213,7 +213,7 @@ pub mod pallet {
 
 		/// Halt or resume all pallet operations.
 		///
-		/// May only be called either by root, or by `ModuleOwner`.
+		/// May only be called either by root, or by `PalletOwner`.
 		#[pallet::weight((T::DbWeight::get().reads_writes(1, 1), DispatchClass::Operational))]
 		pub fn set_operational(origin: OriginFor<T>, operational: bool) -> DispatchResultWithPostInfo {
 			ensure_owner_or_root::<T, I>(origin)?;
@@ -265,7 +265,7 @@ pub mod pallet {
 	/// runtime methods may still be used to do that (i.e. democracy::referendum to update halt
 	/// flag directly or call the `halt_operations`).
 	#[pallet::storage]
-	pub(super) type ModuleOwner<T: Config<I>, I: 'static = ()> = StorageValue<_, T::AccountId, OptionQuery>;
+	pub(super) type PalletOwner<T: Config<I>, I: 'static = ()> = StorageValue<_, T::AccountId, OptionQuery>;
 
 	/// If true, all pallet transactions are failed immediately.
 	#[pallet::storage]
@@ -293,7 +293,7 @@ pub mod pallet {
 	impl<T: Config<I>, I: 'static> GenesisBuild<T, I> for GenesisConfig<T, I> {
 		fn build(&self) {
 			if let Some(ref owner) = self.owner {
-				<ModuleOwner<T, I>>::put(owner);
+				<PalletOwner<T, I>>::put(owner);
 			}
 
 			if let Some(init_data) = self.init_data.clone() {
@@ -426,11 +426,11 @@ pub mod pallet {
 		<IsHalted<T, I>>::put(is_halted);
 	}
 
-	/// Ensure that the origin is either root, or `ModuleOwner`.
+	/// Ensure that the origin is either root, or `PalletOwner`.
 	fn ensure_owner_or_root<T: Config<I>, I: 'static>(origin: T::Origin) -> Result<(), BadOrigin> {
 		match origin.into() {
 			Ok(RawOrigin::Root) => Ok(()),
-			Ok(RawOrigin::Signed(ref signer)) if Some(signer) == <ModuleOwner<T, I>>::get().as_ref() => Ok(()),
+			Ok(RawOrigin::Signed(ref signer)) if Some(signer) == <PalletOwner<T, I>>::get().as_ref() => Ok(()),
 			_ => Err(BadOrigin),
 		}
 	}
@@ -574,22 +574,22 @@ mod tests {
 			is_halted: false,
 		};
 
-		Module::<TestRuntime>::initialize(origin, init_data.clone()).map(|_| init_data)
+		Pallet::<TestRuntime>::initialize(origin, init_data.clone()).map(|_| init_data)
 	}
 
 	fn submit_finality_proof(header: u8) -> frame_support::dispatch::DispatchResultWithPostInfo {
 		let header = test_header(header.into());
 		let justification = make_default_justification(&header);
 
-		Module::<TestRuntime>::submit_finality_proof(Origin::signed(1), header, justification)
+		Pallet::<TestRuntime>::submit_finality_proof(Origin::signed(1), header, justification)
 	}
 
 	fn next_block() {
 		use frame_support::traits::OnInitialize;
 
-		let current_number = frame_system::Module::<TestRuntime>::block_number();
-		frame_system::Module::<TestRuntime>::set_block_number(current_number + 1);
-		let _ = Module::<TestRuntime>::on_initialize(current_number);
+		let current_number = frame_system::Pallet::<TestRuntime>::block_number();
+		frame_system::Pallet::<TestRuntime>::set_block_number(current_number + 1);
+		let _ = Pallet::<TestRuntime>::on_initialize(current_number);
 	}
 
 	fn change_log(delay: u64) -> Digest<TestHash> {
@@ -625,7 +625,7 @@ mod tests {
 
 			// Reset storage so we can initialize the pallet again
 			BestFinalized::<TestRuntime>::kill();
-			ModuleOwner::<TestRuntime>::put(2);
+			PalletOwner::<TestRuntime>::put(2);
 			assert_ok!(init_with_origin(Origin::signed(2)));
 		})
 	}
@@ -637,7 +637,7 @@ mod tests {
 				BestFinalized::<TestRuntime>::get(),
 				BridgedBlockHash::<TestRuntime, ()>::default()
 			);
-			assert_eq!(Module::<TestRuntime>::best_finalized(), test_header(0));
+			assert_eq!(Pallet::<TestRuntime>::best_finalized(), test_header(0));
 
 			let init_data = init_with_origin(Origin::root()).unwrap();
 
@@ -665,56 +665,56 @@ mod tests {
 	#[test]
 	fn pallet_owner_may_change_owner() {
 		run_test(|| {
-			ModuleOwner::<TestRuntime>::put(2);
+			PalletOwner::<TestRuntime>::put(2);
 
-			assert_ok!(Module::<TestRuntime>::set_owner(Origin::root(), Some(1)));
+			assert_ok!(Pallet::<TestRuntime>::set_owner(Origin::root(), Some(1)));
 			assert_noop!(
-				Module::<TestRuntime>::set_operational(Origin::signed(2), false),
+				Pallet::<TestRuntime>::set_operational(Origin::signed(2), false),
 				DispatchError::BadOrigin,
 			);
-			assert_ok!(Module::<TestRuntime>::set_operational(Origin::root(), false));
+			assert_ok!(Pallet::<TestRuntime>::set_operational(Origin::root(), false));
 
-			assert_ok!(Module::<TestRuntime>::set_owner(Origin::signed(1), None));
+			assert_ok!(Pallet::<TestRuntime>::set_owner(Origin::signed(1), None));
 			assert_noop!(
-				Module::<TestRuntime>::set_operational(Origin::signed(1), true),
+				Pallet::<TestRuntime>::set_operational(Origin::signed(1), true),
 				DispatchError::BadOrigin,
 			);
 			assert_noop!(
-				Module::<TestRuntime>::set_operational(Origin::signed(2), true),
+				Pallet::<TestRuntime>::set_operational(Origin::signed(2), true),
 				DispatchError::BadOrigin,
 			);
-			assert_ok!(Module::<TestRuntime>::set_operational(Origin::root(), true));
+			assert_ok!(Pallet::<TestRuntime>::set_operational(Origin::root(), true));
 		});
 	}
 
 	#[test]
 	fn pallet_may_be_halted_by_root() {
 		run_test(|| {
-			assert_ok!(Module::<TestRuntime>::set_operational(Origin::root(), false));
-			assert_ok!(Module::<TestRuntime>::set_operational(Origin::root(), true));
+			assert_ok!(Pallet::<TestRuntime>::set_operational(Origin::root(), false));
+			assert_ok!(Pallet::<TestRuntime>::set_operational(Origin::root(), true));
 		});
 	}
 
 	#[test]
 	fn pallet_may_be_halted_by_owner() {
 		run_test(|| {
-			ModuleOwner::<TestRuntime>::put(2);
+			PalletOwner::<TestRuntime>::put(2);
 
-			assert_ok!(Module::<TestRuntime>::set_operational(Origin::signed(2), false));
-			assert_ok!(Module::<TestRuntime>::set_operational(Origin::signed(2), true));
+			assert_ok!(Pallet::<TestRuntime>::set_operational(Origin::signed(2), false));
+			assert_ok!(Pallet::<TestRuntime>::set_operational(Origin::signed(2), true));
 
 			assert_noop!(
-				Module::<TestRuntime>::set_operational(Origin::signed(1), false),
+				Pallet::<TestRuntime>::set_operational(Origin::signed(1), false),
 				DispatchError::BadOrigin,
 			);
 			assert_noop!(
-				Module::<TestRuntime>::set_operational(Origin::signed(1), true),
+				Pallet::<TestRuntime>::set_operational(Origin::signed(1), true),
 				DispatchError::BadOrigin,
 			);
 
-			assert_ok!(Module::<TestRuntime>::set_operational(Origin::signed(2), false));
+			assert_ok!(Pallet::<TestRuntime>::set_operational(Origin::signed(2), false));
 			assert_noop!(
-				Module::<TestRuntime>::set_operational(Origin::signed(1), true),
+				Pallet::<TestRuntime>::set_operational(Origin::signed(1), true),
 				DispatchError::BadOrigin,
 			);
 		});
@@ -755,7 +755,7 @@ mod tests {
 			let justification = make_justification_for_header(params);
 
 			assert_err!(
-				Module::<TestRuntime>::submit_finality_proof(Origin::signed(1), header, justification,),
+				Pallet::<TestRuntime>::submit_finality_proof(Origin::signed(1), header, justification,),
 				<Error<TestRuntime>>::InvalidJustification
 			);
 		})
@@ -771,7 +771,7 @@ mod tests {
 			justification.round = 42;
 
 			assert_err!(
-				Module::<TestRuntime>::submit_finality_proof(Origin::signed(1), header, justification,),
+				Pallet::<TestRuntime>::submit_finality_proof(Origin::signed(1), header, justification,),
 				<Error<TestRuntime>>::InvalidJustification
 			);
 		})
@@ -790,13 +790,13 @@ mod tests {
 				is_halted: false,
 			};
 
-			assert_ok!(Module::<TestRuntime>::initialize(Origin::root(), init_data));
+			assert_ok!(Pallet::<TestRuntime>::initialize(Origin::root(), init_data));
 
 			let header = test_header(1);
 			let justification = make_default_justification(&header);
 
 			assert_err!(
-				Module::<TestRuntime>::submit_finality_proof(Origin::signed(1), header, justification,),
+				Pallet::<TestRuntime>::submit_finality_proof(Origin::signed(1), header, justification,),
 				<Error<TestRuntime>>::InvalidAuthoritySet
 			);
 		})
@@ -830,7 +830,7 @@ mod tests {
 			let justification = make_default_justification(&header);
 
 			// Let's import our test header
-			assert_ok!(Module::<TestRuntime>::submit_finality_proof(
+			assert_ok!(Pallet::<TestRuntime>::submit_finality_proof(
 				Origin::signed(1),
 				header.clone(),
 				justification
@@ -863,7 +863,7 @@ mod tests {
 
 			// Should not be allowed to import this header
 			assert_err!(
-				Module::<TestRuntime>::submit_finality_proof(Origin::signed(1), header, justification),
+				Pallet::<TestRuntime>::submit_finality_proof(Origin::signed(1), header, justification),
 				<Error<TestRuntime>>::UnsupportedScheduledChange
 			);
 		})
@@ -884,7 +884,7 @@ mod tests {
 
 			// Should not be allowed to import this header
 			assert_err!(
-				Module::<TestRuntime>::submit_finality_proof(Origin::signed(1), header, justification),
+				Pallet::<TestRuntime>::submit_finality_proof(Origin::signed(1), header, justification),
 				<Error<TestRuntime>>::UnsupportedScheduledChange
 			);
 		})
@@ -894,7 +894,7 @@ mod tests {
 	fn parse_finalized_storage_proof_rejects_proof_on_unknown_header() {
 		run_test(|| {
 			assert_noop!(
-				Module::<TestRuntime>::parse_finalized_storage_proof(
+				Pallet::<TestRuntime>::parse_finalized_storage_proof(
 					Default::default(),
 					sp_trie::StorageProof::new(vec![]),
 					|_| (),
@@ -917,7 +917,7 @@ mod tests {
 			<ImportedHeaders<TestRuntime>>::insert(hash, header);
 
 			assert_ok!(
-				Module::<TestRuntime>::parse_finalized_storage_proof(hash, storage_proof, |_| (),),
+				Pallet::<TestRuntime>::parse_finalized_storage_proof(hash, storage_proof, |_| (),),
 				(),
 			);
 		});
@@ -942,7 +942,7 @@ mod tests {
 				let mut invalid_justification = make_default_justification(&header);
 				invalid_justification.round = 42;
 
-				Module::<TestRuntime>::submit_finality_proof(Origin::signed(1), header, invalid_justification)
+				Pallet::<TestRuntime>::submit_finality_proof(Origin::signed(1), header, invalid_justification)
 			};
 
 			initialize_substrate_bridge();

bridges/modules/grandpa/src/mock.rs

@@ -41,8 +41,8 @@ construct_runtime! {
 		NodeBlock = Block,
 		UncheckedExtrinsic = UncheckedExtrinsic,
 	{
-		System: frame_system::{Module, Call, Config, Storage, Event<T>},
-		Grandpa: grandpa::{Module},
+		System: frame_system::{Pallet, Call, Config, Storage, Event<T>},
+		Grandpa: grandpa::{Pallet},
 	}
 }
 
@@ -76,6 +76,7 @@ impl frame_system::Config for TestRuntime {
 	type BlockWeights = ();
 	type BlockLength = ();
 	type SS58Prefix = ();
+	type OnSetCode = ();
 }
 
 parameter_types! {

bridges/modules/messages/rpc/src/lib.rs

@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity Bridges Common.  If not, see <http://www.gnu.org/licenses/>.
 
-//! Module that provides RPC methods specific to messages pallet.
+//! Pallet that provides RPC methods specific to messages pallet.
 
 use crate::error::{Error, FutureResult};
 

bridges/modules/messages/src/benchmarking.rs

@@ -33,8 +33,8 @@ pub const MESSAGE_FEE: u64 = 10_000_000_000;
 
 const SEED: u32 = 0;
 
-/// Module we're benchmarking here.
-pub struct Module<T: Config<I>, I: crate::Instance>(crate::Module<T, I>);
+/// Pallet we're benchmarking here.
+pub struct Pallet<T: Config<I>, I: crate::Instance>(crate::Pallet<T, I>);
 
 /// Proof size requirements.
 pub enum ProofSize {
@@ -142,7 +142,7 @@ benchmarks_instance! {
 	}: send_message(RawOrigin::Signed(sender), lane_id, payload, fee)
 	verify {
 		assert_eq!(
-			crate::Module::<T, I>::outbound_latest_generated_nonce(T::bench_lane_id()),
+			crate::Pallet::<T, I>::outbound_latest_generated_nonce(T::bench_lane_id()),
 			T::MaxMessagesToPruneAtOnce::get() + 1,
 		);
 	}
@@ -179,7 +179,7 @@ benchmarks_instance! {
 	}: send_message(RawOrigin::Signed(sender), lane_id, payload, fee)
 	verify {
 		assert_eq!(
-			crate::Module::<T, I>::outbound_latest_generated_nonce(T::bench_lane_id()),
+			crate::Pallet::<T, I>::outbound_latest_generated_nonce(T::bench_lane_id()),
 			T::MaxMessagesToPruneAtOnce::get() + 1,
 		);
 	}
@@ -216,7 +216,7 @@ benchmarks_instance! {
 	}: send_message(RawOrigin::Signed(sender), lane_id, payload, fee)
 	verify {
 		assert_eq!(
-			crate::Module::<T, I>::outbound_latest_generated_nonce(T::bench_lane_id()),
+			crate::Pallet::<T, I>::outbound_latest_generated_nonce(T::bench_lane_id()),
 			T::MaxMessagesToPruneAtOnce::get() + 1,
 		);
 	}
@@ -261,7 +261,7 @@ benchmarks_instance! {
 	}: receive_messages_proof(RawOrigin::Signed(relayer_id_on_target), relayer_id_on_source, proof, 1, dispatch_weight)
 	verify {
 		assert_eq!(
-			crate::Module::<T, I>::inbound_latest_received_nonce(T::bench_lane_id()),
+			crate::Pallet::<T, I>::inbound_latest_received_nonce(T::bench_lane_id()),
 			21,
 		);
 	}
@@ -292,7 +292,7 @@ benchmarks_instance! {
 	}: receive_messages_proof(RawOrigin::Signed(relayer_id_on_target), relayer_id_on_source, proof, 2, dispatch_weight)
 	verify {
 		assert_eq!(
-			crate::Module::<T, I>::inbound_latest_received_nonce(T::bench_lane_id()),
+			crate::Pallet::<T, I>::inbound_latest_received_nonce(T::bench_lane_id()),
 			22,
 		);
 	}
@@ -327,11 +327,11 @@ benchmarks_instance! {
 	}: receive_messages_proof(RawOrigin::Signed(relayer_id_on_target), relayer_id_on_source, proof, 1, dispatch_weight)
 	verify {
 		assert_eq!(
-			crate::Module::<T, I>::inbound_latest_received_nonce(T::bench_lane_id()),
+			crate::Pallet::<T, I>::inbound_latest_received_nonce(T::bench_lane_id()),
 			21,
 		);
 		assert_eq!(
-			crate::Module::<T, I>::inbound_latest_confirmed_nonce(T::bench_lane_id()),
+			crate::Pallet::<T, I>::inbound_latest_confirmed_nonce(T::bench_lane_id()),
 			20,
 		);
 	}
@@ -361,7 +361,7 @@ benchmarks_instance! {
 	}: receive_messages_proof(RawOrigin::Signed(relayer_id_on_target), relayer_id_on_source, proof, 1, dispatch_weight)
 	verify {
 		assert_eq!(
-			crate::Module::<T, I>::inbound_latest_received_nonce(T::bench_lane_id()),
+			crate::Pallet::<T, I>::inbound_latest_received_nonce(T::bench_lane_id()),
 			21,
 		);
 	}
@@ -393,7 +393,7 @@ benchmarks_instance! {
 	}: receive_messages_proof(RawOrigin::Signed(relayer_id_on_target), relayer_id_on_source, proof, 1, dispatch_weight)
 	verify {
 		assert_eq!(
-			crate::Module::<T, I>::inbound_latest_received_nonce(T::bench_lane_id()),
+			crate::Pallet::<T, I>::inbound_latest_received_nonce(T::bench_lane_id()),
 			21,
 		);
 	}
@@ -404,7 +404,7 @@ benchmarks_instance! {
 	//
 	// This is base benchmark for all other confirmations delivery benchmarks.
 	receive_delivery_proof_for_single_message {
-		let relayers_fund_id = crate::Module::<T, I>::relayer_fund_account_id();
+		let relayers_fund_id = crate::Pallet::<T, I>::relayer_fund_account_id();
 		let relayer_id: T::AccountId = account("relayer", 0, SEED);
 		let relayer_balance = T::account_balance(&relayer_id);
 		T::endow_account(&relayers_fund_id);
@@ -441,7 +441,7 @@ benchmarks_instance! {
 	// as `weight(receive_delivery_proof_for_two_messages_by_single_relayer)
 	//   - weight(receive_delivery_proof_for_single_message)`.
 	receive_delivery_proof_for_two_messages_by_single_relayer {
-		let relayers_fund_id = crate::Module::<T, I>::relayer_fund_account_id();
+		let relayers_fund_id = crate::Pallet::<T, I>::relayer_fund_account_id();
 		let relayer_id: T::AccountId = account("relayer", 0, SEED);
 		let relayer_balance = T::account_balance(&relayer_id);
 		T::endow_account(&relayers_fund_id);
@@ -476,7 +476,7 @@ benchmarks_instance! {
 	// as `weight(receive_delivery_proof_for_two_messages_by_two_relayers)
 	//   - weight(receive_delivery_proof_for_two_messages_by_single_relayer)`.
 	receive_delivery_proof_for_two_messages_by_two_relayers {
-		let relayers_fund_id = crate::Module::<T, I>::relayer_fund_account_id();
+		let relayers_fund_id = crate::Pallet::<T, I>::relayer_fund_account_id();
 		let relayer1_id: T::AccountId = account("relayer1", 1, SEED);
 		let relayer1_balance = T::account_balance(&relayer1_id);
 		let relayer2_id: T::AccountId = account("relayer2", 2, SEED);
@@ -540,7 +540,7 @@ benchmarks_instance! {
 	}: send_message(RawOrigin::Signed(sender), lane_id, payload, fee)
 	verify {
 		assert_eq!(
-			crate::Module::<T, I>::outbound_latest_generated_nonce(T::bench_lane_id()),
+			crate::Pallet::<T, I>::outbound_latest_generated_nonce(T::bench_lane_id()),
 			T::MaxMessagesToPruneAtOnce::get() + 1,
 		);
 	}
@@ -579,7 +579,7 @@ benchmarks_instance! {
 	)
 	verify {
 		assert_eq!(
-			crate::Module::<T, I>::inbound_latest_received_nonce(T::bench_lane_id()),
+			crate::Pallet::<T, I>::inbound_latest_received_nonce(T::bench_lane_id()),
 			20 + i as MessageNonce,
 		);
 	}
@@ -616,7 +616,7 @@ benchmarks_instance! {
 	)
 	verify {
 		assert_eq!(
-			crate::Module::<T, I>::inbound_latest_received_nonce(T::bench_lane_id()),
+			crate::Pallet::<T, I>::inbound_latest_received_nonce(T::bench_lane_id()),
 			21,
 		);
 	}
@@ -653,7 +653,7 @@ benchmarks_instance! {
 	)
 	verify {
 		assert_eq!(
-			crate::Module::<T, I>::inbound_latest_received_nonce(T::bench_lane_id()),
+			crate::Pallet::<T, I>::inbound_latest_received_nonce(T::bench_lane_id()),
 			21,
 		);
 	}
@@ -696,11 +696,11 @@ benchmarks_instance! {
 	)
 	verify {
 		assert_eq!(
-			crate::Module::<T, I>::inbound_latest_received_nonce(T::bench_lane_id()),
+			crate::Pallet::<T, I>::inbound_latest_received_nonce(T::bench_lane_id()),
 			20 + i as MessageNonce,
 		);
 		assert_eq!(
-			crate::Module::<T, I>::inbound_latest_confirmed_nonce(T::bench_lane_id()),
+			crate::Pallet::<T, I>::inbound_latest_confirmed_nonce(T::bench_lane_id()),
 			20,
 		);
 	}
@@ -713,7 +713,7 @@ benchmarks_instance! {
 			.try_into()
 			.expect("Value of MaxUnrewardedRelayerEntriesAtInboundLane is too large");
 
-		let relayers_fund_id = crate::Module::<T, I>::relayer_fund_account_id();
+		let relayers_fund_id = crate::Pallet::<T, I>::relayer_fund_account_id();
 		let relayer_id: T::AccountId = account("relayer", 0, SEED);
 		let relayer_balance = T::account_balance(&relayer_id);
 		T::endow_account(&relayers_fund_id);
@@ -749,7 +749,7 @@ benchmarks_instance! {
 			.try_into()
 			.expect("Value of MaxUnconfirmedMessagesAtInboundLane is too large ");
 
-		let relayers_fund_id = crate::Module::<T, I>::relayer_fund_account_id();
+		let relayers_fund_id = crate::Pallet::<T, I>::relayer_fund_account_id();
 		let confirmation_relayer_id = account("relayer", 0, SEED);
 		let relayers: BTreeMap<T::AccountId, T::OutboundMessageFee> = (1..=i)
 			.map(|j| {

bridges/modules/messages/src/instant_payments.rs

@@ -59,7 +59,7 @@ where
 
 	fn initialize(relayer_fund_account: &T::AccountId) -> usize {
 		assert!(
-			frame_system::Module::<T>::account_exists(relayer_fund_account),
+			frame_system::Pallet::<T>::account_exists(relayer_fund_account),
 			"The relayer fund account ({:?}) must exist for the message lanes pallet to work correctly.",
 			relayer_fund_account,
 		);
@@ -189,7 +189,7 @@ mod tests {
 	use crate::mock::{run_test, AccountId as TestAccountId, Balance as TestBalance, TestRuntime};
 	use bp_messages::source_chain::RelayerRewards;
 
-	type Balances = pallet_balances::Module<TestRuntime>;
+	type Balances = pallet_balances::Pallet<TestRuntime>;
 
 	const RELAYER_1: TestAccountId = 1;
 	const RELAYER_2: TestAccountId = 2;

bridges/modules/messages/src/lib.rs

@@ -161,7 +161,7 @@ type MessagesDeliveryProofOf<T, I> = <<T as Config<I>>::TargetHeaderChain as Tar
 >>::MessagesDeliveryProof;
 
 decl_error! {
-	pub enum Error for Module<T: Config<I>, I: Instance> {
+	pub enum Error for Pallet<T: Config<I>, I: Instance> {
 		/// All pallet operations are halted.
 		Halted,
 		/// Message has been treated as invalid by chain verifier.
@@ -188,14 +188,14 @@ decl_error! {
 }
 
 decl_storage! {
-	trait Store for Module<T: Config<I>, I: Instance = DefaultInstance> as BridgeMessages {
+	trait Store for Pallet<T: Config<I>, I: Instance = DefaultInstance> as BridgeMessages {
 		/// Optional pallet owner.
 		///
 		/// Pallet owner has a right to halt all pallet operations and then resume it. If it is
 		/// `None`, then there are no direct ways to halt/resume pallet operations, but other
 		/// runtime methods may still be used to do that (i.e. democracy::referendum to update halt
 		/// flag directly or call the `halt_operations`).
-		pub ModuleOwner get(fn module_owner): Option<T::AccountId>;
+		pub PalletOwner get(fn module_owner): Option<T::AccountId>;
 		/// If true, all pallet transactions are failed immediately.
 		pub IsHalted get(fn is_halted) config(): bool;
 		/// Map of lane id => inbound lane data.
@@ -210,7 +210,7 @@ decl_storage! {
 		config(owner): Option<T::AccountId>;
 		build(|config| {
 			if let Some(ref owner) = config.owner {
-				<ModuleOwner<T, I>>::put(owner);
+				<PalletOwner<T, I>>::put(owner);
 			}
 		})
 	}
@@ -246,19 +246,19 @@ decl_module! {
 			T::DbWeight::get().reads(reads as u64)
 		}
 
-		/// Change `ModuleOwner`.
+		/// Change `PalletOwner`.
 		///
-		/// May only be called either by root, or by `ModuleOwner`.
+		/// May only be called either by root, or by `PalletOwner`.
 		#[weight = (T::DbWeight::get().reads_writes(1, 1), DispatchClass::Operational)]
 		pub fn set_owner(origin, new_owner: Option<T::AccountId>) {
 			ensure_owner_or_root::<T, I>(origin)?;
 			match new_owner {
 				Some(new_owner) => {
-					ModuleOwner::<T, I>::put(&new_owner);
+					PalletOwner::<T, I>::put(&new_owner);
 					log::info!(target: "runtime::bridge-messages", "Setting pallet Owner to: {:?}", new_owner);
 				},
 				None => {
-					ModuleOwner::<T, I>::kill();
+					PalletOwner::<T, I>::kill();
 					log::info!(target: "runtime::bridge-messages", "Removed Owner of pallet.");
 				},
 			}
@@ -266,7 +266,7 @@ decl_module! {
 
 		/// Halt or resume all pallet operations.
 		///
-		/// May only be called either by root, or by `ModuleOwner`.
+		/// May only be called either by root, or by `PalletOwner`.
 		#[weight = (T::DbWeight::get().reads_writes(1, 1), DispatchClass::Operational)]
 		pub fn set_operational(origin, operational: bool) {
 			ensure_owner_or_root::<T, I>(origin)?;
@@ -281,7 +281,7 @@ decl_module! {
 
 		/// Update pallet parameter.
 		///
-		/// May only be called either by root, or by `ModuleOwner`.
+		/// May only be called either by root, or by `PalletOwner`.
 		///
 		/// The weight is: single read for permissions check + 2 writes for parameter value and event.
 		#[weight = (T::DbWeight::get().reads_writes(1, 2), DispatchClass::Operational)]
@@ -602,7 +602,7 @@ decl_module! {
 	}
 }
 
-impl<T: Config<I>, I: Instance> Module<T, I> {
+impl<T: Config<I>, I: Instance> Pallet<T, I> {
 	/// Get payload of given outbound message.
 	pub fn outbound_message_payload(lane: LaneId, nonce: MessageNonce) -> Option<MessagePayload> {
 		OutboundMessages::<T, I>::get(MessageKey { lane_id: lane, nonce }).map(|message_data| message_data.payload)
@@ -686,11 +686,11 @@ pub mod storage_keys {
 	}
 }
 
-/// Ensure that the origin is either root, or `ModuleOwner`.
+/// Ensure that the origin is either root, or `PalletOwner`.
 fn ensure_owner_or_root<T: Config<I>, I: Instance>(origin: T::Origin) -> Result<(), BadOrigin> {
 	match origin.into() {
 		Ok(RawOrigin::Root) => Ok(()),
-		Ok(RawOrigin::Signed(ref signer)) if Some(signer) == Module::<T, I>::module_owner().as_ref() => Ok(()),
+		Ok(RawOrigin::Signed(ref signer)) if Some(signer) == Pallet::<T, I>::module_owner().as_ref() => Ok(()),
 		_ => Err(BadOrigin),
 	}
 }
@@ -854,7 +854,7 @@ mod tests {
 	};
 	use bp_messages::UnrewardedRelayersState;
 	use frame_support::{assert_noop, assert_ok};
-	use frame_system::{EventRecord, Module as System, Phase};
+	use frame_system::{EventRecord, Pallet as System, Phase};
 	use hex_literal::hex;
 	use sp_runtime::DispatchError;
 
@@ -866,7 +866,7 @@ mod tests {
 	fn send_regular_message() {
 		get_ready_for_events();
 
-		assert_ok!(Module::<TestRuntime>::send_message(
+		assert_ok!(Pallet::<TestRuntime>::send_message(
 			Origin::signed(1),
 			TEST_LANE_ID,
 			REGULAR_PAYLOAD,
@@ -891,7 +891,7 @@ mod tests {
 		System::<TestRuntime>::set_block_number(1);
 		System::<TestRuntime>::reset_events();
 
-		assert_ok!(Module::<TestRuntime>::receive_messages_delivery_proof(
+		assert_ok!(Pallet::<TestRuntime>::receive_messages_delivery_proof(
 			Origin::signed(1),
 			TestMessagesDeliveryProof(Ok((
 				TEST_LANE_ID,
@@ -916,56 +916,56 @@ mod tests {
 	#[test]
 	fn pallet_owner_may_change_owner() {
 		run_test(|| {
-			ModuleOwner::<TestRuntime>::put(2);
+			PalletOwner::<TestRuntime>::put(2);
 
-			assert_ok!(Module::<TestRuntime>::set_owner(Origin::root(), Some(1)));
+			assert_ok!(Pallet::<TestRuntime>::set_owner(Origin::root(), Some(1)));
 			assert_noop!(
-				Module::<TestRuntime>::set_operational(Origin::signed(2), false),
+				Pallet::<TestRuntime>::set_operational(Origin::signed(2), false),
 				DispatchError::BadOrigin,
 			);
-			assert_ok!(Module::<TestRuntime>::set_operational(Origin::root(), false));
+			assert_ok!(Pallet::<TestRuntime>::set_operational(Origin::root(), false));
 
-			assert_ok!(Module::<TestRuntime>::set_owner(Origin::signed(1), None));
+			assert_ok!(Pallet::<TestRuntime>::set_owner(Origin::signed(1), None));
 			assert_noop!(
-				Module::<TestRuntime>::set_operational(Origin::signed(1), true),
+				Pallet::<TestRuntime>::set_operational(Origin::signed(1), true),
 				DispatchError::BadOrigin,
 			);
 			assert_noop!(
-				Module::<TestRuntime>::set_operational(Origin::signed(2), true),
+				Pallet::<TestRuntime>::set_operational(Origin::signed(2), true),
 				DispatchError::BadOrigin,
 			);
-			assert_ok!(Module::<TestRuntime>::set_operational(Origin::root(), true));
+			assert_ok!(Pallet::<TestRuntime>::set_operational(Origin::root(), true));
 		});
 	}
 
 	#[test]
 	fn pallet_may_be_halted_by_root() {
 		run_test(|| {
-			assert_ok!(Module::<TestRuntime>::set_operational(Origin::root(), false));
-			assert_ok!(Module::<TestRuntime>::set_operational(Origin::root(), true));
+			assert_ok!(Pallet::<TestRuntime>::set_operational(Origin::root(), false));
+			assert_ok!(Pallet::<TestRuntime>::set_operational(Origin::root(), true));
 		});
 	}
 
 	#[test]
 	fn pallet_may_be_halted_by_owner() {
 		run_test(|| {
-			ModuleOwner::<TestRuntime>::put(2);
+			PalletOwner::<TestRuntime>::put(2);
 
-			assert_ok!(Module::<TestRuntime>::set_operational(Origin::signed(2), false));
-			assert_ok!(Module::<TestRuntime>::set_operational(Origin::signed(2), true));
+			assert_ok!(Pallet::<TestRuntime>::set_operational(Origin::signed(2), false));
+			assert_ok!(Pallet::<TestRuntime>::set_operational(Origin::signed(2), true));
 
 			assert_noop!(
-				Module::<TestRuntime>::set_operational(Origin::signed(1), false),
+				Pallet::<TestRuntime>::set_operational(Origin::signed(1), false),
 				DispatchError::BadOrigin,
 			);
 			assert_noop!(
-				Module::<TestRuntime>::set_operational(Origin::signed(1), true),
+				Pallet::<TestRuntime>::set_operational(Origin::signed(1), true),
 				DispatchError::BadOrigin,
 			);
 
-			assert_ok!(Module::<TestRuntime>::set_operational(Origin::signed(2), false));
+			assert_ok!(Pallet::<TestRuntime>::set_operational(Origin::signed(2), false));
 			assert_noop!(
-				Module::<TestRuntime>::set_operational(Origin::signed(1), true),
+				Pallet::<TestRuntime>::set_operational(Origin::signed(1), true),
 				DispatchError::BadOrigin,
 			);
 		});
@@ -977,7 +977,7 @@ mod tests {
 			get_ready_for_events();
 
 			let parameter = TestMessagesParameter::TokenConversionRate(10.into());
-			assert_ok!(Module::<TestRuntime>::update_pallet_parameter(
+			assert_ok!(Pallet::<TestRuntime>::update_pallet_parameter(
 				Origin::root(),
 				parameter.clone(),
 			));
@@ -997,11 +997,11 @@ mod tests {
 	#[test]
 	fn pallet_parameter_may_be_updated_by_owner() {
 		run_test(|| {
-			ModuleOwner::<TestRuntime>::put(2);
+			PalletOwner::<TestRuntime>::put(2);
 			get_ready_for_events();
 
 			let parameter = TestMessagesParameter::TokenConversionRate(10.into());
-			assert_ok!(Module::<TestRuntime>::update_pallet_parameter(
+			assert_ok!(Pallet::<TestRuntime>::update_pallet_parameter(
 				Origin::signed(2),
 				parameter.clone(),
 			));
@@ -1022,17 +1022,17 @@ mod tests {
 	fn pallet_parameter_cant_be_updated_by_arbitrary_submitter() {
 		run_test(|| {
 			assert_noop!(
-				Module::<TestRuntime>::update_pallet_parameter(
+				Pallet::<TestRuntime>::update_pallet_parameter(
 					Origin::signed(2),
 					TestMessagesParameter::TokenConversionRate(10.into()),
 				),
 				DispatchError::BadOrigin,
 			);
 
-			ModuleOwner::<TestRuntime>::put(2);
+			PalletOwner::<TestRuntime>::put(2);
 
 			assert_noop!(
-				Module::<TestRuntime>::update_pallet_parameter(
+				Pallet::<TestRuntime>::update_pallet_parameter(
 					Origin::signed(1),
 					TestMessagesParameter::TokenConversionRate(10.into()),
 				),
@@ -1075,7 +1075,7 @@ mod tests {
 			IsHalted::<DefaultInstance>::put(true);
 
 			assert_noop!(
-				Module::<TestRuntime>::send_message(
+				Pallet::<TestRuntime>::send_message(
 					Origin::signed(1),
 					TEST_LANE_ID,
 					REGULAR_PAYLOAD,
@@ -1085,7 +1085,7 @@ mod tests {
 			);
 
 			assert_noop!(
-				Module::<TestRuntime>::receive_messages_proof(
+				Pallet::<TestRuntime>::receive_messages_proof(
 					Origin::signed(1),
 					TEST_RELAYER_A,
 					Ok(vec![message(2, REGULAR_PAYLOAD)]).into(),
@@ -1096,7 +1096,7 @@ mod tests {
 			);
 
 			assert_noop!(
-				Module::<TestRuntime>::receive_messages_delivery_proof(
+				Pallet::<TestRuntime>::receive_messages_delivery_proof(
 					Origin::signed(1),
 					TestMessagesDeliveryProof(Ok((
 						TEST_LANE_ID,
@@ -1124,7 +1124,7 @@ mod tests {
 		run_test(|| {
 			// messages with this payload are rejected by target chain verifier
 			assert_noop!(
-				Module::<TestRuntime>::send_message(
+				Pallet::<TestRuntime>::send_message(
 					Origin::signed(1),
 					TEST_LANE_ID,
 					PAYLOAD_REJECTED_BY_TARGET_CHAIN,
@@ -1140,7 +1140,7 @@ mod tests {
 		run_test(|| {
 			// messages with zero fee are rejected by lane verifier
 			assert_noop!(
-				Module::<TestRuntime>::send_message(Origin::signed(1), TEST_LANE_ID, REGULAR_PAYLOAD, 0),
+				Pallet::<TestRuntime>::send_message(Origin::signed(1), TEST_LANE_ID, REGULAR_PAYLOAD, 0),
 				Error::<TestRuntime, DefaultInstance>::MessageRejectedByLaneVerifier,
 			);
 		});
@@ -1151,7 +1151,7 @@ mod tests {
 		run_test(|| {
 			TestMessageDeliveryAndDispatchPayment::reject_payments();
 			assert_noop!(
-				Module::<TestRuntime>::send_message(
+				Pallet::<TestRuntime>::send_message(
 					Origin::signed(1),
 					TEST_LANE_ID,
 					REGULAR_PAYLOAD,
@@ -1165,7 +1165,7 @@ mod tests {
 	#[test]
 	fn receive_messages_proof_works() {
 		run_test(|| {
-			assert_ok!(Module::<TestRuntime>::receive_messages_proof(
+			assert_ok!(Pallet::<TestRuntime>::receive_messages_proof(
 				Origin::signed(1),
 				TEST_RELAYER_A,
 				Ok(vec![message(1, REGULAR_PAYLOAD)]).into(),
@@ -1191,7 +1191,7 @@ mod tests {
 				},
 			);
 			assert_eq!(
-				Module::<TestRuntime>::inbound_unrewarded_relayers_state(TEST_LANE_ID),
+				Pallet::<TestRuntime>::inbound_unrewarded_relayers_state(TEST_LANE_ID),
 				UnrewardedRelayersState {
 					unrewarded_relayer_entries: 2,
 					messages_in_oldest_entry: 1,
@@ -1206,7 +1206,7 @@ mod tests {
 				..Default::default()
 			});
 
-			assert_ok!(Module::<TestRuntime>::receive_messages_proof(
+			assert_ok!(Pallet::<TestRuntime>::receive_messages_proof(
 				Origin::signed(1),
 				TEST_RELAYER_A,
 				message_proof,
@@ -1224,7 +1224,7 @@ mod tests {
 				},
 			);
 			assert_eq!(
-				Module::<TestRuntime>::inbound_unrewarded_relayers_state(TEST_LANE_ID),
+				Pallet::<TestRuntime>::inbound_unrewarded_relayers_state(TEST_LANE_ID),
 				UnrewardedRelayersState {
 					unrewarded_relayer_entries: 2,
 					messages_in_oldest_entry: 1,
@@ -1238,7 +1238,7 @@ mod tests {
 	fn receive_messages_proof_rejects_invalid_dispatch_weight() {
 		run_test(|| {
 			assert_noop!(
-				Module::<TestRuntime>::receive_messages_proof(
+				Pallet::<TestRuntime>::receive_messages_proof(
 					Origin::signed(1),
 					TEST_RELAYER_A,
 					Ok(vec![message(1, REGULAR_PAYLOAD)]).into(),
@@ -1254,7 +1254,7 @@ mod tests {
 	fn receive_messages_proof_rejects_invalid_proof() {
 		run_test(|| {
 			assert_noop!(
-				Module::<TestRuntime, DefaultInstance>::receive_messages_proof(
+				Pallet::<TestRuntime, DefaultInstance>::receive_messages_proof(
 					Origin::signed(1),
 					TEST_RELAYER_A,
 					Err(()).into(),
@@ -1270,7 +1270,7 @@ mod tests {
 	fn receive_messages_proof_rejects_proof_with_too_many_messages() {
 		run_test(|| {
 			assert_noop!(
-				Module::<TestRuntime, DefaultInstance>::receive_messages_proof(
+				Pallet::<TestRuntime, DefaultInstance>::receive_messages_proof(
 					Origin::signed(1),
 					TEST_RELAYER_A,
 					Ok(vec![message(1, REGULAR_PAYLOAD)]).into(),
@@ -1298,13 +1298,13 @@ mod tests {
 	#[test]
 	fn receive_messages_delivery_proof_rewards_relayers() {
 		run_test(|| {
-			assert_ok!(Module::<TestRuntime>::send_message(
+			assert_ok!(Pallet::<TestRuntime>::send_message(
 				Origin::signed(1),
 				TEST_LANE_ID,
 				REGULAR_PAYLOAD,
 				1000,
 			));
-			assert_ok!(Module::<TestRuntime>::send_message(
+			assert_ok!(Pallet::<TestRuntime>::send_message(
 				Origin::signed(1),
 				TEST_LANE_ID,
 				REGULAR_PAYLOAD,
@@ -1312,7 +1312,7 @@ mod tests {
 			));
 
 			// this reports delivery of message 1 => reward is paid to TEST_RELAYER_A
-			assert_ok!(Module::<TestRuntime>::receive_messages_delivery_proof(
+			assert_ok!(Pallet::<TestRuntime>::receive_messages_delivery_proof(
 				Origin::signed(1),
 				TestMessagesDeliveryProof(Ok((
 					TEST_LANE_ID,
@@ -1337,7 +1337,7 @@ mod tests {
 			));
 
 			// this reports delivery of both message 1 and message 2 => reward is paid only to TEST_RELAYER_B
-			assert_ok!(Module::<TestRuntime>::receive_messages_delivery_proof(
+			assert_ok!(Pallet::<TestRuntime>::receive_messages_delivery_proof(
 				Origin::signed(1),
 				TestMessagesDeliveryProof(Ok((
 					TEST_LANE_ID,
@@ -1369,7 +1369,7 @@ mod tests {
 	fn receive_messages_delivery_proof_rejects_invalid_proof() {
 		run_test(|| {
 			assert_noop!(
-				Module::<TestRuntime>::receive_messages_delivery_proof(
+				Pallet::<TestRuntime>::receive_messages_delivery_proof(
 					Origin::signed(1),
 					TestMessagesDeliveryProof(Err(())),
 					Default::default(),
@@ -1384,7 +1384,7 @@ mod tests {
 		run_test(|| {
 			// when number of relayers entires is invalid
 			assert_noop!(
-				Module::<TestRuntime>::receive_messages_delivery_proof(
+				Pallet::<TestRuntime>::receive_messages_delivery_proof(
 					Origin::signed(1),
 					TestMessagesDeliveryProof(Ok((
 						TEST_LANE_ID,
@@ -1406,7 +1406,7 @@ mod tests {
 
 			// when number of messages is invalid
 			assert_noop!(
-				Module::<TestRuntime>::receive_messages_delivery_proof(
+				Pallet::<TestRuntime>::receive_messages_delivery_proof(
 					Origin::signed(1),
 					TestMessagesDeliveryProof(Ok((
 						TEST_LANE_ID,
@@ -1434,7 +1434,7 @@ mod tests {
 			let mut invalid_message = message(1, REGULAR_PAYLOAD);
 			invalid_message.data.payload = Vec::new();
 
-			assert_ok!(Module::<TestRuntime, DefaultInstance>::receive_messages_proof(
+			assert_ok!(Pallet::<TestRuntime, DefaultInstance>::receive_messages_proof(
 				Origin::signed(1),
 				TEST_RELAYER_A,
 				Ok(vec![invalid_message]).into(),
@@ -1455,7 +1455,7 @@ mod tests {
 			let mut invalid_message = message(2, REGULAR_PAYLOAD);
 			invalid_message.data.payload = Vec::new();
 
-			assert_ok!(Module::<TestRuntime, DefaultInstance>::receive_messages_proof(
+			assert_ok!(Pallet::<TestRuntime, DefaultInstance>::receive_messages_proof(
 				Origin::signed(1),
 				TEST_RELAYER_A,
 				Ok(vec![
@@ -1522,7 +1522,7 @@ mod tests {
 			let message3 = message(2, TestPayload(0, Weight::MAX / 2));
 
 			assert_noop!(
-				Module::<TestRuntime, DefaultInstance>::receive_messages_proof(
+				Pallet::<TestRuntime, DefaultInstance>::receive_messages_proof(
 					Origin::signed(1),
 					TEST_RELAYER_A,
 					// this may cause overflow if source chain storage is invalid
@@ -1542,7 +1542,7 @@ mod tests {
 			receive_messages_delivery_proof();
 
 			assert_noop!(
-				Module::<TestRuntime, DefaultInstance>::increase_message_fee(Origin::signed(1), TEST_LANE_ID, 1, 100,),
+				Pallet::<TestRuntime, DefaultInstance>::increase_message_fee(Origin::signed(1), TEST_LANE_ID, 1, 100,),
 				Error::<TestRuntime, DefaultInstance>::MessageIsAlreadyDelivered,
 			);
 		});
@@ -1552,7 +1552,7 @@ mod tests {
 	fn increase_message_fee_fails_if_message_is_not_yet_sent() {
 		run_test(|| {
 			assert_noop!(
-				Module::<TestRuntime, DefaultInstance>::increase_message_fee(Origin::signed(1), TEST_LANE_ID, 1, 100,),
+				Pallet::<TestRuntime, DefaultInstance>::increase_message_fee(Origin::signed(1), TEST_LANE_ID, 1, 100,),
 				Error::<TestRuntime, DefaultInstance>::MessageIsNotYetSent,
 			);
 		});
@@ -1566,7 +1566,7 @@ mod tests {
 			TestMessageDeliveryAndDispatchPayment::reject_payments();
 
 			assert_noop!(
-				Module::<TestRuntime, DefaultInstance>::increase_message_fee(Origin::signed(1), TEST_LANE_ID, 1, 100,),
+				Pallet::<TestRuntime, DefaultInstance>::increase_message_fee(Origin::signed(1), TEST_LANE_ID, 1, 100,),
 				Error::<TestRuntime, DefaultInstance>::FailedToWithdrawMessageFee,
 			);
 		});
@@ -1577,7 +1577,7 @@ mod tests {
 		run_test(|| {
 			send_regular_message();
 
-			assert_ok!(Module::<TestRuntime, DefaultInstance>::increase_message_fee(
+			assert_ok!(Pallet::<TestRuntime, DefaultInstance>::increase_message_fee(
 				Origin::signed(1),
 				TEST_LANE_ID,
 				1,

bridges/modules/messages/src/mock.rs

@@ -64,9 +64,9 @@ frame_support::construct_runtime! {
 		NodeBlock = Block,
 		UncheckedExtrinsic = UncheckedExtrinsic,
 	{
-		System: frame_system::{Module, Call, Config, Storage, Event<T>},
-		Balances: pallet_balances::{Module, Call, Event<T>},
-		Messages: pallet_bridge_messages::{Module, Call, Event<T>},
+		System: frame_system::{Pallet, Call, Config, Storage, Event<T>},
+		Balances: pallet_balances::{Pallet, Call, Event<T>},
+		Messages: pallet_bridge_messages::{Pallet, Call, Event<T>},
 	}
 }
 
@@ -100,6 +100,7 @@ impl frame_system::Config for TestRuntime {
 	type BlockLength = ();
 	type DbWeight = ();
 	type SS58Prefix = ();
+	type OnSetCode = ();
 }
 
 parameter_types! {
@@ -112,7 +113,7 @@ impl pallet_balances::Config for TestRuntime {
 	type DustRemoval = ();
 	type Event = Event;
 	type ExistentialDeposit = ExistentialDeposit;
-	type AccountStore = frame_system::Module<TestRuntime>;
+	type AccountStore = frame_system::Pallet<TestRuntime>;
 	type WeightInfo = ();
 }
 

bridges/modules/shift-session-manager/src/lib.rs

@@ -31,13 +31,13 @@ decl_module! {
 }
 
 decl_storage! {
-	trait Store for Module<T: Config> as ShiftSessionManager {
+	trait Store for Pallet<T: Config> as ShiftSessionManager {
 		/// Validators of first two sessions.
 		InitialValidators: Option<Vec<T::ValidatorId>>;
 	}
 }
 
-impl<T: Config> pallet_session::SessionManager<T::ValidatorId> for Module<T> {
+impl<T: Config> pallet_session::SessionManager<T::ValidatorId> for Pallet<T> {
 	fn end_session(_: sp_staking::SessionIndex) {}
 	fn start_session(_: sp_staking::SessionIndex) {}
 	fn new_session(session_index: sp_staking::SessionIndex) -> Option<Vec<T::ValidatorId>> {
@@ -52,7 +52,7 @@ impl<T: Config> pallet_session::SessionManager<T::ValidatorId> for Module<T> {
 		// then for every session we select (deterministically) 2/3 of these initial
 		// validators to serve validators of new session
 		let available_validators = InitialValidators::<T>::get().unwrap_or_else(|| {
-			let validators = <pallet_session::Module<T>>::validators();
+			let validators = <pallet_session::Pallet<T>>::validators();
 			InitialValidators::<T>::put(validators.clone());
 			validators
 		});
@@ -61,7 +61,7 @@ impl<T: Config> pallet_session::SessionManager<T::ValidatorId> for Module<T> {
 	}
 }
 
-impl<T: Config> Module<T> {
+impl<T: Config> Pallet<T> {
 	/// Select validators for session.
 	fn select_validators(
 		session_index: sp_staking::SessionIndex,
@@ -110,8 +110,8 @@ mod tests {
 			NodeBlock = Block,
 			UncheckedExtrinsic = UncheckedExtrinsic,
 		{
-			System: frame_system::{Module, Call, Config, Storage, Event<T>},
-			Session: pallet_session::{Module},
+			System: frame_system::{Pallet, Call, Config, Storage, Event<T>},
+			Session: pallet_session::{Pallet},
 		}
 	}
 
@@ -145,6 +145,7 @@ mod tests {
 		type BlockLength = ();
 		type DbWeight = ();
 		type SS58Prefix = ();
+		type OnSetCode = ();
 	}
 
 	parameter_types! {
@@ -193,7 +194,7 @@ mod tests {
 
 		BasicExternalities::execute_with_storage(&mut t, || {
 			for (ref k, ..) in &keys {
-				frame_system::Module::<TestRuntime>::inc_providers(k);
+				frame_system::Pallet::<TestRuntime>::inc_providers(k);
 			}
 		});
 
@@ -209,19 +210,19 @@ mod tests {
 			let all_accs = vec![1, 2, 3, 4, 5];
 
 			// at least 1 validator is selected
-			assert_eq!(Module::<TestRuntime>::select_validators(0, &[1]), vec![1],);
+			assert_eq!(Pallet::<TestRuntime>::select_validators(0, &[1]), vec![1],);
 
 			// at session#0, shift is also 0
-			assert_eq!(Module::<TestRuntime>::select_validators(0, &all_accs), vec![1, 2, 3],);
+			assert_eq!(Pallet::<TestRuntime>::select_validators(0, &all_accs), vec![1, 2, 3],);
 
 			// at session#1, shift is also 1
-			assert_eq!(Module::<TestRuntime>::select_validators(1, &all_accs), vec![2, 3, 4],);
+			assert_eq!(Pallet::<TestRuntime>::select_validators(1, &all_accs), vec![2, 3, 4],);
 
 			// at session#3, we're wrapping
-			assert_eq!(Module::<TestRuntime>::select_validators(3, &all_accs), vec![4, 5, 1],);
+			assert_eq!(Pallet::<TestRuntime>::select_validators(3, &all_accs), vec![4, 5, 1],);
 
 			// at session#5, we're starting from the beginning again
-			assert_eq!(Module::<TestRuntime>::select_validators(5, &all_accs), vec![1, 2, 3],);
+			assert_eq!(Pallet::<TestRuntime>::select_validators(5, &all_accs), vec![1, 2, 3],);
 		});
 	}
 }

bridges/primitives/chain-millau/src/lib.rs

@@ -76,7 +76,7 @@ pub const MAX_UNCONFIRMED_MESSAGES_AT_INBOUND_LANE: MessageNonce = 1024;
 
 /// Weight of single regular message delivery transaction on Millau chain.
 ///
-/// This value is a result of `pallet_bridge_messages::Module::receive_messages_proof_weight()` call
+/// This value is a result of `pallet_bridge_messages::Pallet::receive_messages_proof_weight()` call
 /// for the case when single message of `pallet_bridge_messages::EXPECTED_DEFAULT_MESSAGE_LENGTH` bytes is delivered.
 /// The message must have dispatch weight set to zero. The result then must be rounded up to account
 /// possible future runtime upgrades.
@@ -90,7 +90,7 @@ pub const ADDITIONAL_MESSAGE_BYTE_DELIVERY_WEIGHT: Weight = 25_000;
 
 /// Maximal weight of single message delivery confirmation transaction on Millau chain.
 ///
-/// This value is a result of `pallet_bridge_messages::Module::receive_messages_delivery_proof` weight formula computation
+/// This value is a result of `pallet_bridge_messages::Pallet::receive_messages_delivery_proof` weight formula computation
 /// for the case when single message is confirmed. The result then must be rounded up to account possible future
 /// runtime upgrades.
 pub const MAX_SINGLE_MESSAGE_DELIVERY_CONFIRMATION_TX_WEIGHT: Weight = 2_000_000_000;

bridges/primitives/chain-rialto/src/lib.rs

@@ -67,7 +67,7 @@ pub const MAX_UNCONFIRMED_MESSAGES_AT_INBOUND_LANE: MessageNonce = 128;
 
 /// Weight of single regular message delivery transaction on Rialto chain.
 ///
-/// This value is a result of `pallet_bridge_messages::Module::receive_messages_proof_weight()` call
+/// This value is a result of `pallet_bridge_messages::Pallet::receive_messages_proof_weight()` call
 /// for the case when single message of `pallet_bridge_messages::EXPECTED_DEFAULT_MESSAGE_LENGTH` bytes is delivered.
 /// The message must have dispatch weight set to zero. The result then must be rounded up to account
 /// possible future runtime upgrades.
@@ -81,7 +81,7 @@ pub const ADDITIONAL_MESSAGE_BYTE_DELIVERY_WEIGHT: Weight = 25_000;
 
 /// Maximal weight of single message delivery confirmation transaction on Rialto chain.
 ///
-/// This value is a result of `pallet_bridge_messages::Module::receive_messages_delivery_proof` weight formula computation
+/// This value is a result of `pallet_bridge_messages::Pallet::receive_messages_delivery_proof` weight formula computation
 /// for the case when single message is confirmed. The result then must be rounded up to account possible future
 /// runtime upgrades.
 pub const MAX_SINGLE_MESSAGE_DELIVERY_CONFIRMATION_TX_WEIGHT: Weight = 2_000_000_000;

bridges/primitives/chain-rococo/src/lib.rs

@@ -41,7 +41,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
 
 #[derive(parity_scale_codec::Encode, parity_scale_codec::Decode, Debug, PartialEq, Eq, Clone)]
 pub enum Call {
-	MockModule,
+	MockPallet,
 }
 
 impl sp_runtime::traits::Dispatchable for Call {

bridges/primitives/header-chain/src/justification.rs

@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity Bridges Common.  If not, see <http://www.gnu.org/licenses/>.
 
-//! Module for checking GRANDPA Finality Proofs.
+//! Pallet for checking GRANDPA Finality Proofs.
 //!
 //! Adapted copy of substrate/client/finality-grandpa/src/justification.rs. If origin
 //! will ever be moved to the sp_finality_grandpa, we should reuse that implementation.

bridges/relays/bin-ethereum/src/ethereum_client.rs

@@ -29,7 +29,7 @@ use relay_ethereum_client::{
 };
 use relay_rialto_client::HeaderId as RialtoHeaderId;
 use relay_utils::{HeaderId, MaybeConnectionError};
-use sp_runtime::Justification;
+use sp_runtime::EncodedJustification;
 use std::collections::HashSet;
 
 // to encode/decode contract calls
@@ -68,7 +68,7 @@ pub trait EthereumHighLevelRpc {
 		params: EthereumSigningParams,
 		contract_address: Address,
 		id: RialtoHeaderId,
-		justification: Justification,
+		justification: EncodedJustification,
 	) -> RpcResult<RialtoHeaderId>;
 
 	/// Submit ethereum transaction.
@@ -194,7 +194,7 @@ impl EthereumHighLevelRpc for EthereumClient {
 		params: EthereumSigningParams,
 		contract_address: Address,
 		id: RialtoHeaderId,
-		justification: Justification,
+		justification: EncodedJustification,
 	) -> RpcResult<RialtoHeaderId> {
 		let _ = self
 			.submit_ethereum_transaction(

bridges/relays/bin-ethereum/src/substrate_sync_loop.rs

@@ -36,7 +36,7 @@ use relay_substrate_client::{
 	ConnectionParams as SubstrateConnectionParams,
 };
 use relay_utils::{metrics::MetricsParams, relay_loop::Client as RelayClient};
-use sp_runtime::Justification;
+use sp_runtime::EncodedJustification;
 
 use std::fmt::Debug;
 use std::{collections::HashSet, time::Duration};
@@ -84,7 +84,7 @@ impl HeadersSyncPipeline for SubstrateHeadersSyncPipeline {
 	type Number = rialto_runtime::BlockNumber;
 	type Header = RialtoSyncHeader;
 	type Extra = ();
-	type Completion = Justification;
+	type Completion = EncodedJustification;
 
 	fn estimate_size(source: &QueuedHeader<Self>) -> usize {
 		source.header().encode().len()
@@ -151,7 +151,11 @@ impl TargetClient<SubstrateHeadersSyncPipeline> for EthereumHeadersTarget {
 		self.client.incomplete_substrate_headers(self.contract).await
 	}
 
-	async fn complete_header(&self, id: RialtoHeaderId, completion: Justification) -> Result<RialtoHeaderId, RpcError> {
+	async fn complete_header(
+		&self,
+		id: RialtoHeaderId,
+		completion: EncodedJustification,
+	) -> Result<RialtoHeaderId, RpcError> {
 		self.client
 			.complete_substrate_header(self.sign_params.clone(), self.contract, id, completion)
 			.await

bridges/relays/client-substrate/Cargo.toml

@@ -32,6 +32,7 @@ frame-system = { git = "https://github.com/paritytech/substrate", branch = "mast
 pallet-balances = { git = "https://github.com/paritytech/substrate", branch = "master" }
 sc-rpc-api = { git = "https://github.com/paritytech/substrate", branch = "master" }
 sp-core = { git = "https://github.com/paritytech/substrate", branch = "master" }
+sp-finality-grandpa = { git = "https://github.com/paritytech/substrate", branch = "master" }
 sp-runtime = { git = "https://github.com/paritytech/substrate", branch = "master" }
 sp-std = { git = "https://github.com/paritytech/substrate", branch = "master" }
 sp-trie = { git = "https://github.com/paritytech/substrate", branch = "master" }

bridges/relays/client-substrate/src/chain.rs

@@ -24,7 +24,7 @@ use sp_runtime::{
 	traits::{
 		AtLeast32Bit, Block as BlockT, Dispatchable, MaybeDisplay, MaybeSerialize, MaybeSerializeDeserialize, Member,
 	},
-	Justification,
+	EncodedJustification,
 };
 use std::{fmt::Debug, time::Duration};
 
@@ -71,7 +71,7 @@ pub trait BlockWithJustification<Header> {
 	/// Return block header.
 	fn header(&self) -> Header;
 	/// Return block justification, if known.
-	fn justification(&self) -> Option<&Justification>;
+	fn justification(&self) -> Option<&EncodedJustification>;
 }
 
 /// Substrate-based chain transactions signing scheme.
@@ -97,7 +97,9 @@ impl<Block: BlockT> BlockWithJustification<Block::Header> for SignedBlock<Block>
 		self.block.header().clone()
 	}
 
-	fn justification(&self) -> Option<&Justification> {
-		self.justification.as_ref()
+	fn justification(&self) -> Option<&EncodedJustification> {
+		self.justifications
+			.as_ref()
+			.and_then(|j| j.get(sp_finality_grandpa::GRANDPA_ENGINE_ID))
 	}
 }

bridges/relays/client-substrate/src/guard.rs

@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity Bridges Common.  If not, see <http://www.gnu.org/licenses/>.
 
-//! Module provides a set of guard functions that are running in background threads
+//! Pallet provides a set of guard functions that are running in background threads
 //! and are aborting process if some condition fails.
 
 use crate::{Chain, ChainWithBalances, Client};

bridges/relays/client-substrate/src/headers_source.rs

@@ -26,7 +26,7 @@ use headers_relay::{
 	sync_types::{HeaderIdOf, HeadersSyncPipeline, QueuedHeader, SourceHeader},
 };
 use relay_utils::relay_loop::Client as RelayClient;
-use sp_runtime::{traits::Header as HeaderT, Justification};
+use sp_runtime::{traits::Header as HeaderT, EncodedJustification};
 use std::marker::PhantomData;
 
 /// Substrate node as headers source.
@@ -69,7 +69,7 @@ where
 	C: Chain,
 	C::BlockNumber: relay_utils::BlockNumberBase,
 	C::Header: Into<P::Header>,
-	P: HeadersSyncPipeline<Extra = (), Completion = Justification, Hash = C::Hash, Number = C::BlockNumber>,
+	P: HeadersSyncPipeline<Extra = (), Completion = EncodedJustification, Hash = C::Hash, Number = C::BlockNumber>,
 	P::Header: SourceHeader<C::Hash, C::BlockNumber>,
 {
 	async fn best_block_number(&self) -> Result<P::Number, Error> {

bridges/relays/headers/src/lib.rs

@@ -16,7 +16,7 @@
 
 //! Relaying source chain headers to target chain. This module provides entrypoint
 //! that starts reading new headers from source chain and submit these headers as
-//! module/contract transactions to the target chain. Module/contract on the target
+//! module/contract transactions to the target chain. Pallet/contract on the target
 //! chain is a light-client of the source chain. All other trustless bridge
 //! applications are built using this light-client, so running headers-relay is
 //! essential for running all other bridge applications.