Squashed 'bridges/' content from commit 062554430

git-subtree-dir: bridges
git-subtree-split: 0625544309ff299307f7e110f252f04eac383102

primitives/test-utils/Cargo.toml

@@ -0,0 +1,32 @@
+[package]
+name = "bp-test-utils"
+version = "0.1.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+
+[dependencies]
+bp-header-chain = { path = "../header-chain", default-features = false  }
+codec = { package = "parity-scale-codec", version = "3.1.5", default-features = false }
+ed25519-dalek = { version = "1.0", default-features = false, features = ["u64_backend"] }
+finality-grandpa = { version = "0.16.0", default-features = false }
+sp-application-crypto = { git = "https://github.com/paritytech/substrate", branch = "master", default-features = false }
+sp-finality-grandpa = { git = "https://github.com/paritytech/substrate", branch = "master", default-features = false  }
+sp-runtime = { git = "https://github.com/paritytech/substrate", branch = "master", default-features = false }
+sp-std = { git = "https://github.com/paritytech/substrate", branch = "master", default-features = false }
+
+[dev-dependencies]
+xcm = { git = "https://github.com/paritytech/polkadot", branch = "master", default-features = false }
+
+[features]
+default = ["std"]
+std = [
+	"bp-header-chain/std",
+	"codec/std",
+	"ed25519-dalek/std",
+	"finality-grandpa/std",
+	"sp-application-crypto/std",
+	"sp-finality-grandpa/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]

primitives/test-utils/src/keyring.rs

@@ -0,0 +1,94 @@
+// Copyright 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/>.
+
+//! Utilities for working with test accounts.
+
+use codec::Encode;
+use ed25519_dalek::{Keypair, PublicKey, SecretKey, Signature};
+use finality_grandpa::voter_set::VoterSet;
+use sp_finality_grandpa::{AuthorityId, AuthorityList, AuthorityWeight};
+use sp_runtime::RuntimeDebug;
+use sp_std::prelude::*;
+
+/// Set of test accounts with friendly names.
+pub const ALICE: Account = Account(0);
+pub const BOB: Account = Account(1);
+pub const CHARLIE: Account = Account(2);
+pub const DAVE: Account = Account(3);
+pub const EVE: Account = Account(4);
+pub const FERDIE: Account = Account(5);
+
+/// A test account which can be used to sign messages.
+#[derive(RuntimeDebug, Clone, Copy)]
+pub struct Account(pub u16);
+
+impl Account {
+	pub fn public(&self) -> PublicKey {
+		(&self.secret()).into()
+	}
+
+	pub fn secret(&self) -> SecretKey {
+		let data = self.0.encode();
+		let mut bytes = [0_u8; 32];
+		bytes[0..data.len()].copy_from_slice(&data);
+		SecretKey::from_bytes(&bytes)
+			.expect("A static array of the correct length is a known good.")
+	}
+
+	pub fn pair(&self) -> Keypair {
+		let mut pair: [u8; 64] = [0; 64];
+
+		let secret = self.secret();
+		pair[..32].copy_from_slice(&secret.to_bytes());
+
+		let public = self.public();
+		pair[32..].copy_from_slice(&public.to_bytes());
+
+		Keypair::from_bytes(&pair)
+			.expect("We expect the SecretKey to be good, so this must also be good.")
+	}
+
+	pub fn sign(&self, msg: &[u8]) -> Signature {
+		use ed25519_dalek::Signer;
+		self.pair().sign(msg)
+	}
+}
+
+impl From<Account> for AuthorityId {
+	fn from(p: Account) -> Self {
+		sp_application_crypto::UncheckedFrom::unchecked_from(p.public().to_bytes())
+	}
+}
+
+/// Get a valid set of voters for a Grandpa round.
+pub fn voter_set() -> VoterSet<AuthorityId> {
+	VoterSet::new(authority_list()).unwrap()
+}
+
+/// Convenience function to get a list of Grandpa authorities.
+pub fn authority_list() -> AuthorityList {
+	test_keyring().iter().map(|(id, w)| (AuthorityId::from(*id), *w)).collect()
+}
+
+/// Get the corresponding identities from the keyring for the "standard" authority set.
+pub fn test_keyring() -> Vec<(Account, AuthorityWeight)> {
+	vec![(ALICE, 1), (BOB, 1), (CHARLIE, 1)]
+}
+
+/// Get a list of "unique" accounts.
+pub fn accounts(len: u16) -> Vec<Account> {
+	(0..len).into_iter().map(Account).collect()
+}

primitives/test-utils/src/lib.rs

@@ -0,0 +1,345 @@
+// Copyright 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/>.
+
+//! Utilities for testing runtime code.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use bp_header_chain::justification::GrandpaJustification;
+use codec::Encode;
+use sp_finality_grandpa::{AuthorityId, AuthoritySignature, AuthorityWeight, SetId};
+use sp_runtime::traits::{Header as HeaderT, One, Zero};
+use sp_std::prelude::*;
+
+// Re-export all our test account utilities
+pub use keyring::*;
+
+mod keyring;
+
+pub const TEST_GRANDPA_ROUND: u64 = 1;
+pub const TEST_GRANDPA_SET_ID: SetId = 1;
+
+/// Configuration parameters when generating test GRANDPA justifications.
+#[derive(Clone)]
+pub struct JustificationGeneratorParams<H> {
+	/// The header which we want to finalize.
+	pub header: H,
+	/// The GRANDPA round number for the current authority set.
+	pub round: u64,
+	/// The current authority set ID.
+	pub set_id: SetId,
+	/// The current GRANDPA authority set.
+	///
+	/// The size of the set will determine the number of pre-commits in our justification.
+	pub authorities: Vec<(Account, AuthorityWeight)>,
+	/// The total number of precommit ancestors in the `votes_ancestries` field our justification.
+	///
+	/// These may be distributed among many forks.
+	pub ancestors: u32,
+	/// The number of forks.
+	///
+	/// Useful for creating a "worst-case" scenario in which each authority is on its own fork.
+	pub forks: u32,
+}
+
+impl<H: HeaderT> Default for JustificationGeneratorParams<H> {
+	fn default() -> Self {
+		Self {
+			header: test_header(One::one()),
+			round: TEST_GRANDPA_ROUND,
+			set_id: TEST_GRANDPA_SET_ID,
+			authorities: test_keyring(),
+			ancestors: 2,
+			forks: 1,
+		}
+	}
+}
+
+/// Make a valid GRANDPA justification with sensible defaults
+pub fn make_default_justification<H: HeaderT>(header: &H) -> GrandpaJustification<H> {
+	let params = JustificationGeneratorParams::<H> { header: header.clone(), ..Default::default() };
+
+	make_justification_for_header(params)
+}
+
+/// Generate justifications in a way where we are able to tune the number of pre-commits
+/// and vote ancestries which are included in the justification.
+///
+/// This is useful for benchmarkings where we want to generate valid justifications with
+/// a specific number of pre-commits (tuned with the number of "authorities") and/or a specific
+/// number of vote ancestries (tuned with the "votes" parameter).
+///
+/// Note: This needs at least three authorities or else the verifier will complain about
+/// being given an invalid commit.
+pub fn make_justification_for_header<H: HeaderT>(
+	params: JustificationGeneratorParams<H>,
+) -> GrandpaJustification<H> {
+	let JustificationGeneratorParams { header, round, set_id, authorities, mut ancestors, forks } =
+		params;
+	let (target_hash, target_number) = (header.hash(), *header.number());
+	let mut votes_ancestries = vec![];
+	let mut precommits = vec![];
+
+	assert!(forks != 0, "Need at least one fork to have a chain..");
+	assert!(
+		forks as usize <= authorities.len(),
+		"If we have more forks than authorities we can't create valid pre-commits for all the forks."
+	);
+
+	// Roughly, how many vote ancestries do we want per fork
+	let target_depth = (ancestors + forks - 1) / forks;
+
+	let mut unsigned_precommits = vec![];
+	for i in 0..forks {
+		let depth = if ancestors >= target_depth {
+			ancestors -= target_depth;
+			target_depth
+		} else {
+			ancestors
+		};
+
+		// Note: Adding 1 to account for the target header
+		let chain = generate_chain(i, depth + 1, &header);
+
+		// We don't include our finality target header in the vote ancestries
+		for child in &chain[1..] {
+			votes_ancestries.push(child.clone());
+		}
+
+		// The header we need to use when pre-commiting is the one at the highest height
+		// on our chain.
+		let precommit_candidate = chain.last().map(|h| (h.hash(), *h.number())).unwrap();
+		unsigned_precommits.push(precommit_candidate);
+	}
+
+	for (i, (id, _weight)) in authorities.iter().enumerate() {
+		// Assign authorities to sign pre-commits in a round-robin fashion
+		let target = unsigned_precommits[i % forks as usize];
+		let precommit = signed_precommit::<H>(id, target, round, set_id);
+
+		precommits.push(precommit);
+	}
+
+	GrandpaJustification {
+		round,
+		commit: finality_grandpa::Commit { target_hash, target_number, precommits },
+		votes_ancestries,
+	}
+}
+
+fn generate_chain<H: HeaderT>(fork_id: u32, depth: u32, ancestor: &H) -> Vec<H> {
+	let mut headers = vec![ancestor.clone()];
+
+	for i in 1..depth {
+		let parent = &headers[(i - 1) as usize];
+		let (hash, num) = (parent.hash(), *parent.number());
+
+		let mut header = test_header::<H>(num + One::one());
+		header.set_parent_hash(hash);
+
+		// Modifying the digest so headers at the same height but in different forks have different
+		// hashes
+		header.digest_mut().logs.push(sp_runtime::DigestItem::Other(fork_id.encode()));
+
+		headers.push(header);
+	}
+
+	headers
+}
+
+/// Create signed precommit with given target.
+pub fn signed_precommit<H: HeaderT>(
+	signer: &Account,
+	target: (H::Hash, H::Number),
+	round: u64,
+	set_id: SetId,
+) -> finality_grandpa::SignedPrecommit<H::Hash, H::Number, AuthoritySignature, AuthorityId> {
+	let precommit = finality_grandpa::Precommit { target_hash: target.0, target_number: target.1 };
+
+	let encoded = sp_finality_grandpa::localized_payload(
+		round,
+		set_id,
+		&finality_grandpa::Message::Precommit(precommit.clone()),
+	);
+
+	let signature = signer.sign(&encoded);
+	let raw_signature: Vec<u8> = signature.to_bytes().into();
+
+	// Need to wrap our signature and id types that they match what our `SignedPrecommit` is
+	// expecting
+	let signature = AuthoritySignature::try_from(raw_signature).expect(
+		"We know our Keypair is good,
+		so our signature must also be good.",
+	);
+	let id = (*signer).into();
+
+	finality_grandpa::SignedPrecommit { precommit, signature, id }
+}
+
+/// Get a header for testing.
+///
+/// The correct parent hash will be used if given a non-zero header.
+pub fn test_header<H: HeaderT>(number: H::Number) -> H {
+	let default = |num| {
+		H::new(num, Default::default(), Default::default(), Default::default(), Default::default())
+	};
+
+	let mut header = default(number);
+	if number != Zero::zero() {
+		let parent_hash = default(number - One::one()).hash();
+		header.set_parent_hash(parent_hash);
+	}
+
+	header
+}
+
+/// Convenience function for generating a Header ID at a given block number.
+pub fn header_id<H: HeaderT>(index: u8) -> (H::Hash, H::Number) {
+	(test_header::<H>(index.into()).hash(), index.into())
+}
+
+#[macro_export]
+/// Adds methods for testing the `set_owner()` and `set_operating_mode()` for a pallet.
+/// Some values are hardcoded like:
+/// - `run_test()`
+/// - `Pallet::<TestRuntime>`
+/// - `PalletOwner::<TestRuntime>`
+/// - `PalletOperatingMode::<TestRuntime>`
+/// While this is not ideal, all the pallets use the same names, so it works for the moment.
+/// We can revisit this in the future if anything changes.
+macro_rules! generate_owned_bridge_module_tests {
+	($normal_operating_mode: expr, $halted_operating_mode: expr) => {
+		#[test]
+		fn test_set_owner() {
+			run_test(|| {
+				PalletOwner::<TestRuntime>::put(1);
+
+				// The root should be able to change the owner.
+				assert_ok!(Pallet::<TestRuntime>::set_owner(RuntimeOrigin::root(), Some(2)));
+				assert_eq!(PalletOwner::<TestRuntime>::get(), Some(2));
+
+				// The owner should be able to change the owner.
+				assert_ok!(Pallet::<TestRuntime>::set_owner(RuntimeOrigin::signed(2), Some(3)));
+				assert_eq!(PalletOwner::<TestRuntime>::get(), Some(3));
+
+				// Other users shouldn't be able to change the owner.
+				assert_noop!(
+					Pallet::<TestRuntime>::set_owner(RuntimeOrigin::signed(1), Some(4)),
+					DispatchError::BadOrigin
+				);
+				assert_eq!(PalletOwner::<TestRuntime>::get(), Some(3));
+			});
+		}
+
+		#[test]
+		fn test_set_operating_mode() {
+			run_test(|| {
+				PalletOwner::<TestRuntime>::put(1);
+				PalletOperatingMode::<TestRuntime>::put($normal_operating_mode);
+
+				// The root should be able to halt the pallet.
+				assert_ok!(Pallet::<TestRuntime>::set_operating_mode(
+					RuntimeOrigin::root(),
+					$halted_operating_mode
+				));
+				assert_eq!(PalletOperatingMode::<TestRuntime>::get(), $halted_operating_mode);
+				// The root should be able to resume the pallet.
+				assert_ok!(Pallet::<TestRuntime>::set_operating_mode(
+					RuntimeOrigin::root(),
+					$normal_operating_mode
+				));
+				assert_eq!(PalletOperatingMode::<TestRuntime>::get(), $normal_operating_mode);
+
+				// The owner should be able to halt the pallet.
+				assert_ok!(Pallet::<TestRuntime>::set_operating_mode(
+					RuntimeOrigin::signed(1),
+					$halted_operating_mode
+				));
+				assert_eq!(PalletOperatingMode::<TestRuntime>::get(), $halted_operating_mode);
+				// The owner should be able to resume the pallet.
+				assert_ok!(Pallet::<TestRuntime>::set_operating_mode(
+					RuntimeOrigin::signed(1),
+					$normal_operating_mode
+				));
+				assert_eq!(PalletOperatingMode::<TestRuntime>::get(), $normal_operating_mode);
+
+				// Other users shouldn't be able to halt the pallet.
+				assert_noop!(
+					Pallet::<TestRuntime>::set_operating_mode(
+						RuntimeOrigin::signed(2),
+						$halted_operating_mode
+					),
+					DispatchError::BadOrigin
+				);
+				assert_eq!(PalletOperatingMode::<TestRuntime>::get(), $normal_operating_mode);
+				// Other users shouldn't be able to resume the pallet.
+				PalletOperatingMode::<TestRuntime>::put($halted_operating_mode);
+				assert_noop!(
+					Pallet::<TestRuntime>::set_operating_mode(
+						RuntimeOrigin::signed(2),
+						$normal_operating_mode
+					),
+					DispatchError::BadOrigin
+				);
+				assert_eq!(PalletOperatingMode::<TestRuntime>::get(), $halted_operating_mode);
+			});
+		}
+	};
+}
+
+#[cfg(test)]
+mod tests {
+	use codec::Encode;
+	use sp_application_crypto::sp_core::{hexdisplay, hexdisplay::HexDisplay};
+	use xcm::VersionedXcm;
+
+	fn print_xcm<RuntimeCall>(xcm: &VersionedXcm<RuntimeCall>) {
+		println!("-----------------");
+		println!("xcm (plain): {:?}", xcm);
+		println!("xcm (bytes): {:?}", xcm.encode());
+		println!("xcm (hex): {:?}", hexdisplay::HexDisplay::from(&xcm.encode()));
+	}
+
+	fn as_hex<RuntimeCall>(xcm: &VersionedXcm<RuntimeCall>) -> String {
+		HexDisplay::from(&xcm.encode()).to_string()
+	}
+
+	pub type RuntimeCall = ();
+
+	#[test]
+	fn generate_versioned_xcm_message_hex_bytes() {
+		let xcm: xcm::v2::Xcm<RuntimeCall> = xcm::v2::Xcm(vec![xcm::v2::Instruction::Trap(43)]);
+		let xcm: VersionedXcm<RuntimeCall> = From::from(xcm);
+		print_xcm(&xcm);
+		assert_eq!("020419ac", format!("{}", as_hex(&xcm)));
+
+		let xcm: xcm::v3::Xcm<RuntimeCall> = vec![xcm::v3::Instruction::Trap(43)].into();
+		let xcm: VersionedXcm<RuntimeCall> = From::from(xcm);
+		print_xcm(&xcm);
+		assert_eq!("030419ac", format!("{}", as_hex(&xcm)));
+
+		let xcm: xcm::v3::Xcm<RuntimeCall> = vec![
+			xcm::v3::Instruction::ClearError,
+			xcm::v3::Instruction::ClearTopic,
+			xcm::v3::Instruction::ClearTransactStatus,
+			xcm::v3::Instruction::Trap(43),
+		]
+		.into();
+		let xcm: VersionedXcm<RuntimeCall> = From::from(xcm);
+		print_xcm(&xcm);
+		assert_eq!("0310172c2319ac", format!("{}", as_hex(&xcm)));
+	}
+}