Parachains pallet benchmarks

bin/millau/runtime/Cargo.toml

@@ -145,6 +145,7 @@ runtime-benchmarks = [
 	"frame-system/runtime-benchmarks",
 	"libsecp256k1",
 	"pallet-bridge-messages/runtime-benchmarks",
+	"pallet-bridge-parachains/runtime-benchmarks",
 	"pallet-xcm/runtime-benchmarks",
 	"sp-runtime/runtime-benchmarks",
 	"xcm-builder/runtime-benchmarks",

bin/millau/runtime/src/lib.rs

@@ -515,9 +515,10 @@ parameter_types! {
 }
 
 /// Instance of the with-Rialto parachains token swap pallet.
-pub type WitRialtoParachainsInstance = ();
+pub type WithRialtoParachainsInstance = ();
 
-impl pallet_bridge_parachains::Config<WitRialtoParachainsInstance> for Runtime {
+impl pallet_bridge_parachains::Config<WithRialtoParachainsInstance> for Runtime {
+	type WeightInfo = pallet_bridge_parachains::weights::MillauWeight<Runtime>;
 	type BridgesGrandpaPalletInstance = RialtoGrandpaInstance;
 	type ParasPalletName = RialtoParasPalletName;
 	type TrackedParachains = frame_support::traits::Everything;
@@ -807,7 +808,7 @@ impl_runtime_apis! {
 			use bp_rialto_parachain::RIALTO_PARACHAIN_ID;
 			let best_rialto_parachain_head = pallet_bridge_parachains::Pallet::<
 				Runtime,
-				WitRialtoParachainsInstance,
+				WithRialtoParachainsInstance,
 			>::best_parachain_head(RIALTO_PARACHAIN_ID.into())
 				.and_then(|encoded_header| bp_rialto_parachain::Header::decode(&mut &encoded_header.0[..]).ok());
 			match best_rialto_parachain_head {
@@ -901,11 +902,13 @@ impl_runtime_apis! {
 			use frame_support::traits::StorageInfoTrait;
 
 			use pallet_bridge_messages::benchmarking::Pallet as MessagesBench;
+			use pallet_bridge_parachains::benchmarking::Pallet as ParachainsBench;
 
 			let mut list = Vec::<BenchmarkList>::new();
 
 			list_benchmark!(list, extra, pallet_bridge_messages, MessagesBench::<Runtime, WithRialtoMessagesInstance>);
 			list_benchmark!(list, extra, pallet_bridge_grandpa, BridgeRialtoGrandpa);
+			list_benchmark!(list, extra, pallet_bridge_parachains, ParachainsBench::<Runtime, WithRialtoMessagesInstance>);
 
 			let storage_info = AllPalletsWithSystem::storage_info();
 
@@ -942,6 +945,10 @@ impl_runtime_apis! {
 				MessageParams,
 				MessageProofParams,
 			};
+			use pallet_bridge_parachains::benchmarking::{
+				Pallet as ParachainsBench,
+				Config as ParachainsConfig,
+			};
 			use rialto_messages::WithRialtoMessageBridge;
 
 			impl MessagesConfig<WithRialtoMessagesInstance> for Runtime {
@@ -991,6 +998,19 @@ impl_runtime_apis! {
 				}
 			}
 
+			impl ParachainsConfig<WithRialtoParachainsInstance> for Runtime {
+				fn prepare_parachain_heads_proof(
+					parachains: &[bp_polkadot_core::parachains::ParaId],
+					parachain_head_size: u32,
+					proof_size: bp_runtime::StorageProofSize,
+				) -> (pallet_bridge_parachains::RelayBlockHash, bp_polkadot_core::parachains::ParaHeadsProof) {
+					bridge_runtime_common::parachains_benchmarking::prepare_parachain_heads_proof::<Runtime, WithRialtoParachainsInstance>(
+						parachains,
+						parachain_head_size,
+						proof_size,
+					)
+				}
+			}
 
 			add_benchmark!(
 				params,
@@ -999,6 +1019,12 @@ impl_runtime_apis! {
 				MessagesBench::<Runtime, WithRialtoMessagesInstance>
 			);
 			add_benchmark!(params, batches, pallet_bridge_grandpa, BridgeRialtoGrandpa);
+			add_benchmark!(
+				params,
+				batches,
+				pallet_bridge_parachains,
+				ParachainsBench::<Runtime, WithRialtoParachainsInstance>
+			);
 
 			Ok(batches)
 		}

bin/millau/runtime/src/rialto_parachain_messages.rs

@@ -252,7 +252,7 @@ impl TargetHeaderChain<ToRialtoParachainMessagePayload, bp_rialto_parachain::Acc
 			WithRialtoParachainMessageBridge,
 			bp_rialto_parachain::Header,
 			Runtime,
-			crate::WitRialtoParachainsInstance,
+			crate::WithRialtoParachainsInstance,
 		>(ParaId(bp_rialto_parachain::RIALTO_PARACHAIN_ID), proof)
 	}
 }
@@ -274,7 +274,7 @@ impl SourceHeaderChain<bp_rialto_parachain::Balance> for RialtoParachain {
 			WithRialtoParachainMessageBridge,
 			bp_rialto_parachain::Header,
 			Runtime,
-			crate::WitRialtoParachainsInstance,
+			crate::WithRialtoParachainsInstance,
 		>(ParaId(bp_rialto_parachain::RIALTO_PARACHAIN_ID), proof, messages_count)
 	}
 }

bin/runtime-common/Cargo.toml

@@ -18,6 +18,7 @@ static_assertions = { version = "1.1", optional = true }
 # Bridge dependencies
 
 bp-messages = { path = "../../primitives/messages", default-features = false }
+bp-parachains = { path = "../../primitives/parachains", default-features = false }
 bp-polkadot-core = { path = "../../primitives/polkadot-core", default-features = false }
 bp-runtime = { path = "../../primitives/runtime", default-features = false }
 pallet-bridge-grandpa = { path = "../../modules/grandpa", default-features = false }
@@ -49,6 +50,7 @@ xcm-executor = { git = "https://github.com/paritytech/polkadot", branch = "gav-x
 default = ["std"]
 std = [
 	"bp-messages/std",
+	"bp-parachains/std",
 	"bp-polkadot-core/std",
 	"bp-runtime/std",
 	"codec/std",

bin/runtime-common/src/lib.rs

@@ -21,6 +21,7 @@
 pub mod messages;
 pub mod messages_api;
 pub mod messages_benchmarking;
+pub mod parachains_benchmarking;
 
 #[cfg(feature = "integrity-test")]
 pub mod integrity;

bin/runtime-common/src/messages_benchmarking.rs

@@ -27,10 +27,11 @@ use crate::messages::{
 };
 
 use bp_messages::{storage_keys, MessageData, MessageKey, MessagePayload};
+use bp_runtime::StorageProofSize;
 use codec::Encode;
 use frame_support::weights::{GetDispatchInfo, Weight};
 use pallet_bridge_messages::benchmarking::{
-	MessageDeliveryProofParams, MessageParams, MessageProofParams, ProofSize,
+	MessageDeliveryProofParams, MessageParams, MessageProofParams,
 };
 use sp_core::Hasher;
 use sp_runtime::traits::{Header, IdentifyAccount, MaybeSerializeDeserialize, Zero};
@@ -59,7 +60,7 @@ where
 	R: frame_system::Config<AccountId = AccountIdOf<ThisChain<B>>>
 		+ pallet_balances::Config<BI, Balance = BalanceOf<ThisChain<B>>>
 		+ pallet_bridge_grandpa::Config<FI>,
-	R::BridgedChain: bp_runtime::Chain<Header = BH>,
+	R::BridgedChain: bp_runtime::Chain<Hash = HashOf<BridgedChain<B>>, Header = BH>,
 	B: MessageBridge,
 	BI: 'static,
 	FI: 'static,
@@ -76,14 +77,14 @@ where
 		+ IdentifyAccount<AccountId = AccountIdOf<ThisChain<B>>>,
 {
 	let message_payload = match params.size {
-		ProofSize::Minimal(ref size) => vec![0u8; *size as _],
+		StorageProofSize::Minimal(ref size) => vec![0u8; *size as _],
 		_ => vec![],
 	};
 
 	// finally - prepare storage proof and update environment
 	let (state_root, storage_proof) =
 		prepare_messages_storage_proof::<B, BHH>(&params, message_payload);
-	let bridged_header_hash = insert_bridged_chain_header::<R, FI, B, BH>(state_root);
+	let bridged_header_hash = insert_header_to_grandpa_pallet::<R, FI>(state_root);
 
 	(
 		FromBridgedChainMessagesProof {
@@ -103,7 +104,7 @@ pub fn prepare_message_delivery_proof<R, FI, B, BH, BHH>(
 ) -> FromBridgedChainMessagesDeliveryProof<HashOf<BridgedChain<B>>>
 where
 	R: pallet_bridge_grandpa::Config<FI>,
-	R::BridgedChain: bp_runtime::Chain<Header = BH>,
+	R::BridgedChain: bp_runtime::Chain<Hash = HashOf<BridgedChain<B>>, Header = BH>,
 	FI: 'static,
 	B: MessageBridge,
 	BH: Header<Hash = HashOf<BridgedChain<B>>>,
@@ -131,7 +132,7 @@ where
 	let storage_proof = proof_recorder.drain().into_iter().map(|n| n.data.to_vec()).collect();
 
 	// finally insert header with given state root to our storage
-	let bridged_header_hash = insert_bridged_chain_header::<R, FI, B, BH>(root);
+	let bridged_header_hash = insert_header_to_grandpa_pallet::<R, FI>(root);
 
 	FromBridgedChainMessagesDeliveryProof {
 		bridged_header_hash: bridged_header_hash.into(),
@@ -203,36 +204,37 @@ where
 	(root, storage_proof)
 }
 
-/// Insert Bridged chain header with given state root into storage of GRANDPA pallet at This chain.
-fn insert_bridged_chain_header<R, FI, B, BH>(
-	state_root: HashOf<BridgedChain<B>>,
-) -> HashOf<BridgedChain<B>>
+/// Insert header to the bridge GRANDPA pallet.
+pub(crate) fn insert_header_to_grandpa_pallet<R, GI>(
+	state_root: bp_runtime::HashOf<R::BridgedChain>,
+) -> bp_runtime::HashOf<R::BridgedChain>
 where
-	R: pallet_bridge_grandpa::Config<FI>,
-	R::BridgedChain: bp_runtime::Chain<Header = BH>,
-	FI: 'static,
-	B: MessageBridge,
-	BH: Header<Hash = HashOf<BridgedChain<B>>>,
-	HashOf<BridgedChain<B>>: Default,
+	R: pallet_bridge_grandpa::Config<GI>,
+	GI: 'static,
+	R::BridgedChain: bp_runtime::Chain,
 {
-	let bridged_header = BH::new(
+	let bridged_header = bp_runtime::HeaderOf::<R::BridgedChain>::new(
 		Zero::zero(),
 		Default::default(),
 		state_root,
 		Default::default(),
 		Default::default(),
 	);
 	let bridged_header_hash = bridged_header.hash();
-	pallet_bridge_grandpa::initialize_for_benchmarks::<R, FI>(bridged_header);
+	pallet_bridge_grandpa::initialize_for_benchmarks::<R, GI>(bridged_header);
 	bridged_header_hash
 }
 
 /// Populate trie with dummy keys+values until trie has at least given size.
-fn grow_trie<H: Hasher>(mut root: H::Out, mdb: &mut MemoryDB<H>, trie_size: ProofSize) -> H::Out {
+pub fn grow_trie<H: Hasher>(
+	mut root: H::Out,
+	mdb: &mut MemoryDB<H>,
+	trie_size: StorageProofSize,
+) -> H::Out {
 	let (iterations, leaf_size, minimal_trie_size) = match trie_size {
-		ProofSize::Minimal(_) => return root,
-		ProofSize::HasLargeLeaf(size) => (1, size, size),
-		ProofSize::HasExtraNodes(size) => (8, 1, size),
+		StorageProofSize::Minimal(_) => return root,
+		StorageProofSize::HasLargeLeaf(size) => (1, size, size),
+		StorageProofSize::HasExtraNodes(size) => (8, 1, size),
 	};
 
 	let mut key_index = 0;

bin/runtime-common/src/parachains_benchmarking.rs

@@ -0,0 +1,80 @@
+// Copyright 2019-2021 Parity Technologies (UK) Ltd.
+// This file is part of Parity Bridges Common.
+
+// Parity Bridges Common is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity Bridges Common is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// 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/>.
+
+//! Everything required to run benchmarks of parachains finality module.
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use crate::messages_benchmarking::{grow_trie, insert_header_to_grandpa_pallet};
+
+use bp_parachains::parachain_head_storage_key_at_source;
+use bp_polkadot_core::parachains::{ParaHead, ParaHeadsProof, ParaId};
+use bp_runtime::StorageProofSize;
+use codec::Encode;
+use frame_support::traits::Get;
+use pallet_bridge_parachains::{RelayBlockHash, RelayBlockHasher};
+use sp_std::prelude::*;
+use sp_trie::{record_all_keys, trie_types::TrieDBMutV1, LayoutV1, MemoryDB, Recorder, TrieMut};
+
+/// Prepare proof of messages for the `receive_messages_proof` call.
+///
+/// In addition to returning valid messages proof, environment is prepared to verify this message
+/// proof.
+pub fn prepare_parachain_heads_proof<R, PI>(
+	parachains: &[ParaId],
+	parachain_head_size: u32,
+	size: StorageProofSize,
+) -> (RelayBlockHash, ParaHeadsProof)
+where
+	R: pallet_bridge_parachains::Config<PI>
+		+ pallet_bridge_grandpa::Config<R::BridgesGrandpaPalletInstance>,
+	PI: 'static,
+	<R as pallet_bridge_grandpa::Config<R::BridgesGrandpaPalletInstance>>::BridgedChain:
+		bp_runtime::Chain<Hash = RelayBlockHash>,
+{
+	let parachain_head = ParaHead(vec![0u8; parachain_head_size as usize]);
+
+	// insert all heads to the trie
+	let mut storage_keys = Vec::with_capacity(parachains.len());
+	let mut state_root = Default::default();
+	let mut mdb = MemoryDB::default();
+	{
+		let mut trie = TrieDBMutV1::<RelayBlockHasher>::new(&mut mdb, &mut state_root);
+
+		// insert parachain heads
+		for parachain in parachains {
+			let storage_key =
+				parachain_head_storage_key_at_source(R::ParasPalletName::get(), *parachain);
+			trie.insert(&storage_key.0, &parachain_head.encode())
+				.map_err(|_| "TrieMut::insert has failed")
+				.expect("TrieMut::insert should not fail in benchmarks");
+			storage_keys.push(storage_key);
+		}
+	}
+	state_root = grow_trie(state_root, &mut mdb, size);
+
+	// generate heads storage proof
+	let mut proof_recorder = Recorder::<RelayBlockHash>::new();
+	record_all_keys::<LayoutV1<RelayBlockHasher>, _>(&mdb, &state_root, &mut proof_recorder)
+		.map_err(|_| "record_all_keys has failed")
+		.expect("record_all_keys should not fail in benchmarks");
+	let proof = proof_recorder.drain().into_iter().map(|n| n.data.to_vec()).collect();
+
+	let relay_block_hash =
+		insert_header_to_grandpa_pallet::<R, R::BridgesGrandpaPalletInstance>(state_root);
+
+	(relay_block_hash, ParaHeadsProof(proof))
+}