Bridges subtree sync (#2991)

* Squashed 'bridges/' changes from 0417308a48..278119fec2

278119fec2 Grandpa: Store the authority set changes (#2336) (#2337)
19f9c8ffdb remove message sender origin (#2322)
3c7c271d2e GRANDPA module: store accepted justifications (#2298) (#2301)
fb7d12e793 GRANDPA justifications: equivocation detection primitives (#2295) (#2297)
d03a2ed450 More backports from Cumulus subtree to polkadot-staging (#2283)
3c4ada921b Update dependecies (#2277) (#2281)
3e195c9e76 GRANDPA: optimize votes_ancestries when needed (#2262) (#2264)
7065bbabc6 Implement RuntimeDebug for GrandpaJustification (#2254)
8c9e59bcbc Define generate_grandpa_key_ownership_proof() (#2247) (#2248)
0b46956df7 Deduplicate Grandpa consensus log reading logic (#2245) (#2246)
96c9701710 Fix deps from Cumulus (#2244)

git-subtree-dir: bridges
git-subtree-split: 278119fec2b45990cf1271999b0c21befe7003d9

* Subtree update

* Squashed 'bridges/' changes from 278119fec2..edf33a2c85

edf33a2c85 Backport fix (for wasm `std` env) (#2339)

git-subtree-dir: bridges
git-subtree-split: edf33a2c85399d366e008228f2d9e63e8a492d95

cumulus/bridges/primitives/header-chain/tests/implementation_match.rs

@@ -21,7 +21,9 @@
 //! Some of tests in this module may partially duplicate tests from `justification.rs`,
 //! but their purpose is different.
 
-use bp_header_chain::justification::{verify_justification, Error, GrandpaJustification};
+use bp_header_chain::justification::{
+	verify_justification, GrandpaJustification, JustificationVerificationError, PrecommitError,
+};
 use bp_test_utils::{
 	header_id, make_justification_for_header, signed_precommit, test_header, Account,
 	JustificationGeneratorParams, ALICE, BOB, CHARLIE, DAVE, EVE, FERDIE, TEST_GRANDPA_SET_ID,
@@ -85,13 +87,6 @@ fn minimal_accounts_set() -> Vec<(Account, AuthorityWeight)> {
 	vec![(ALICE, 1), (BOB, 1), (CHARLIE, 1), (DAVE, 1)]
 }
 
-/// Get a minimal subset of GRANDPA authorities that have enough cumulative vote weight to justify a
-/// header finality.
-pub fn minimal_voter_set() -> VoterSet<AuthorityId> {
-	VoterSet::new(minimal_accounts_set().iter().map(|(id, w)| (AuthorityId::from(*id), *w)))
-		.unwrap()
-}
-
 /// Make a valid GRANDPA justification with sensible defaults.
 pub fn make_default_justification(header: &TestHeader) -> GrandpaJustification<TestHeader> {
 	make_justification_for_header(JustificationGeneratorParams {
@@ -124,7 +119,7 @@ fn same_result_when_precommit_target_has_lower_number_than_commit_target() {
 			&full_voter_set(),
 			&justification,
 		),
-		Err(Error::UnrelatedAncestryVote),
+		Err(JustificationVerificationError::Precommit(PrecommitError::UnrelatedAncestryVote)),
 	);
 
 	// original implementation returns `Ok(validation_result)`
@@ -157,7 +152,7 @@ fn same_result_when_precommit_target_is_not_descendant_of_commit_target() {
 			&full_voter_set(),
 			&justification,
 		),
-		Err(Error::UnrelatedAncestryVote),
+		Err(JustificationVerificationError::Precommit(PrecommitError::UnrelatedAncestryVote)),
 	);
 
 	// original implementation returns `Ok(validation_result)`
@@ -191,7 +186,7 @@ fn same_result_when_there_are_not_enough_cumulative_weight_to_finalize_commit_ta
 			&full_voter_set(),
 			&justification,
 		),
-		Err(Error::TooLowCumulativeWeight),
+		Err(JustificationVerificationError::TooLowCumulativeWeight),
 	);
 	// original implementation returns `Ok(validation_result)`
 	// with `validation_result.is_valid() == false`.
@@ -229,7 +224,7 @@ fn different_result_when_justification_contains_duplicate_vote() {
 			&full_voter_set(),
 			&justification,
 		),
-		Err(Error::DuplicateAuthorityVote),
+		Err(JustificationVerificationError::Precommit(PrecommitError::DuplicateAuthorityVote)),
 	);
 	// original implementation returns `Ok(validation_result)`
 	// with `validation_result.is_valid() == true`.
@@ -270,7 +265,7 @@ fn different_results_when_authority_equivocates_once_in_a_round() {
 			&full_voter_set(),
 			&justification,
 		),
-		Err(Error::DuplicateAuthorityVote),
+		Err(JustificationVerificationError::Precommit(PrecommitError::DuplicateAuthorityVote)),
 	);
 	// original implementation returns `Ok(validation_result)`
 	// with `validation_result.is_valid() == true`.
@@ -323,7 +318,7 @@ fn different_results_when_authority_equivocates_twice_in_a_round() {
 			&full_voter_set(),
 			&justification,
 		),
-		Err(Error::DuplicateAuthorityVote),
+		Err(JustificationVerificationError::Precommit(PrecommitError::DuplicateAuthorityVote)),
 	);
 	// original implementation returns `Ok(validation_result)`
 	// with `validation_result.is_valid() == true`.
@@ -362,7 +357,7 @@ fn different_results_when_there_are_more_than_enough_votes() {
 			&full_voter_set(),
 			&justification,
 		),
-		Err(Error::RedundantVotesInJustification),
+		Err(JustificationVerificationError::Precommit(PrecommitError::RedundantAuthorityVote)),
 	);
 	// original implementation returns `Ok(validation_result)`
 	// with `validation_result.is_valid() == true`.
@@ -403,7 +398,7 @@ fn different_results_when_there_is_a_vote_of_unknown_authority() {
 			&full_voter_set(),
 			&justification,
 		),
-		Err(Error::UnknownAuthorityVote),
+		Err(JustificationVerificationError::Precommit(PrecommitError::UnknownAuthorityVote)),
 	);
 	// original implementation returns `Ok(validation_result)`
 	// with `validation_result.is_valid() == true`.

cumulus/bridges/primitives/header-chain/tests/justification/equivocation.rs

@@ -0,0 +1,124 @@
+// Copyright 2020-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/>.
+
+//! Tests for Grandpa equivocations collector code.
+
+use bp_header_chain::justification::EquivocationsCollector;
+use bp_test_utils::*;
+use finality_grandpa::Precommit;
+use sp_consensus_grandpa::EquivocationProof;
+
+type TestHeader = sp_runtime::testing::Header;
+
+#[test]
+fn duplicate_votes_are_not_considered_equivocations() {
+	let voter_set = voter_set();
+	let base_justification = make_default_justification::<TestHeader>(&test_header(1));
+
+	let mut collector =
+		EquivocationsCollector::new(TEST_GRANDPA_SET_ID, &voter_set, &base_justification).unwrap();
+	collector.parse_justification(&base_justification.clone()).unwrap();
+
+	assert_eq!(collector.into_equivocation_proofs().len(), 0);
+}
+
+#[test]
+fn equivocations_are_detected_in_base_justification_redundant_votes() {
+	let voter_set = voter_set();
+	let mut base_justification = make_default_justification::<TestHeader>(&test_header(1));
+
+	let first_vote = base_justification.commit.precommits[0].clone();
+	let equivocation = signed_precommit::<TestHeader>(
+		&ALICE,
+		header_id::<TestHeader>(1),
+		base_justification.round,
+		TEST_GRANDPA_SET_ID,
+	);
+	base_justification.commit.precommits.push(equivocation.clone());
+
+	let collector =
+		EquivocationsCollector::new(TEST_GRANDPA_SET_ID, &voter_set, &base_justification).unwrap();
+
+	assert_eq!(
+		collector.into_equivocation_proofs(),
+		vec![EquivocationProof::new(
+			1,
+			sp_consensus_grandpa::Equivocation::Precommit(finality_grandpa::Equivocation {
+				round_number: 1,
+				identity: ALICE.into(),
+				first: (
+					Precommit {
+						target_hash: first_vote.precommit.target_hash,
+						target_number: first_vote.precommit.target_number
+					},
+					first_vote.signature
+				),
+				second: (
+					Precommit {
+						target_hash: equivocation.precommit.target_hash,
+						target_number: equivocation.precommit.target_number
+					},
+					equivocation.signature
+				)
+			})
+		)]
+	);
+}
+
+#[test]
+fn equivocations_are_detected_in_extra_justification_redundant_votes() {
+	let voter_set = voter_set();
+	let base_justification = make_default_justification::<TestHeader>(&test_header(1));
+	let first_vote = base_justification.commit.precommits[0].clone();
+
+	let mut extra_justification = base_justification.clone();
+	let equivocation = signed_precommit::<TestHeader>(
+		&ALICE,
+		header_id::<TestHeader>(1),
+		base_justification.round,
+		TEST_GRANDPA_SET_ID,
+	);
+	extra_justification.commit.precommits.push(equivocation.clone());
+
+	let mut collector =
+		EquivocationsCollector::new(TEST_GRANDPA_SET_ID, &voter_set, &base_justification).unwrap();
+	collector.parse_justification(&extra_justification).unwrap();
+
+	assert_eq!(
+		collector.into_equivocation_proofs(),
+		vec![EquivocationProof::new(
+			1,
+			sp_consensus_grandpa::Equivocation::Precommit(finality_grandpa::Equivocation {
+				round_number: 1,
+				identity: ALICE.into(),
+				first: (
+					Precommit {
+						target_hash: first_vote.precommit.target_hash,
+						target_number: first_vote.precommit.target_number
+					},
+					first_vote.signature
+				),
+				second: (
+					Precommit {
+						target_hash: equivocation.precommit.target_hash,
+						target_number: equivocation.precommit.target_number
+					},
+					equivocation.signature
+				)
+			})
+		)]
+	);
+}

cumulus/bridges/primitives/header-chain/tests/justification/optimizer.rs

@@ -14,189 +14,15 @@
 // 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/>.
 
-//! Tests for Grandpa Justification code.
+//! Tests for Grandpa Justification optimizer code.
 
-use bp_header_chain::justification::{
-	required_justification_precommits, verify_and_optimize_justification, verify_justification,
-	Error,
-};
+use bp_header_chain::justification::verify_and_optimize_justification;
 use bp_test_utils::*;
 use finality_grandpa::SignedPrecommit;
 use sp_consensus_grandpa::AuthoritySignature;
 
 type TestHeader = sp_runtime::testing::Header;
 
-#[test]
-fn valid_justification_accepted() {
-	let authorities = vec![(ALICE, 1), (BOB, 1), (CHARLIE, 1)];
-	let params = JustificationGeneratorParams {
-		header: test_header(1),
-		round: TEST_GRANDPA_ROUND,
-		set_id: TEST_GRANDPA_SET_ID,
-		authorities: authorities.clone(),
-		ancestors: 7,
-		forks: 3,
-	};
-
-	let justification = make_justification_for_header::<TestHeader>(params.clone());
-	assert_eq!(
-		verify_justification::<TestHeader>(
-			header_id::<TestHeader>(1),
-			TEST_GRANDPA_SET_ID,
-			&voter_set(),
-			&justification,
-		),
-		Ok(()),
-	);
-
-	assert_eq!(justification.commit.precommits.len(), authorities.len());
-	assert_eq!(justification.votes_ancestries.len(), params.ancestors as usize);
-}
-
-#[test]
-fn valid_justification_accepted_with_single_fork() {
-	let params = JustificationGeneratorParams {
-		header: test_header(1),
-		round: TEST_GRANDPA_ROUND,
-		set_id: TEST_GRANDPA_SET_ID,
-		authorities: vec![(ALICE, 1), (BOB, 1), (CHARLIE, 1)],
-		ancestors: 5,
-		forks: 1,
-	};
-
-	assert_eq!(
-		verify_justification::<TestHeader>(
-			header_id::<TestHeader>(1),
-			TEST_GRANDPA_SET_ID,
-			&voter_set(),
-			&make_justification_for_header::<TestHeader>(params)
-		),
-		Ok(()),
-	);
-}
-
-#[test]
-fn valid_justification_accepted_with_arbitrary_number_of_authorities() {
-	use finality_grandpa::voter_set::VoterSet;
-	use sp_consensus_grandpa::AuthorityId;
-
-	let n = 15;
-	let required_signatures = required_justification_precommits(n as _);
-	let authorities = accounts(n).iter().map(|k| (*k, 1)).collect::<Vec<_>>();
-
-	let params = JustificationGeneratorParams {
-		header: test_header(1),
-		round: TEST_GRANDPA_ROUND,
-		set_id: TEST_GRANDPA_SET_ID,
-		authorities: authorities.clone().into_iter().take(required_signatures as _).collect(),
-		ancestors: n.into(),
-		forks: required_signatures,
-	};
-
-	let authorities = authorities
-		.iter()
-		.map(|(id, w)| (AuthorityId::from(*id), *w))
-		.collect::<Vec<(AuthorityId, _)>>();
-	let voter_set = VoterSet::new(authorities).unwrap();
-
-	assert_eq!(
-		verify_justification::<TestHeader>(
-			header_id::<TestHeader>(1),
-			TEST_GRANDPA_SET_ID,
-			&voter_set,
-			&make_justification_for_header::<TestHeader>(params)
-		),
-		Ok(()),
-	);
-}
-
-#[test]
-fn justification_with_invalid_target_rejected() {
-	assert_eq!(
-		verify_justification::<TestHeader>(
-			header_id::<TestHeader>(2),
-			TEST_GRANDPA_SET_ID,
-			&voter_set(),
-			&make_default_justification::<TestHeader>(&test_header(1)),
-		),
-		Err(Error::InvalidJustificationTarget),
-	);
-}
-
-#[test]
-fn justification_with_invalid_commit_rejected() {
-	let mut justification = make_default_justification::<TestHeader>(&test_header(1));
-	justification.commit.precommits.clear();
-
-	assert_eq!(
-		verify_justification::<TestHeader>(
-			header_id::<TestHeader>(1),
-			TEST_GRANDPA_SET_ID,
-			&voter_set(),
-			&justification,
-		),
-		Err(Error::TooLowCumulativeWeight),
-	);
-}
-
-#[test]
-fn justification_with_invalid_authority_signature_rejected() {
-	let mut justification = make_default_justification::<TestHeader>(&test_header(1));
-	justification.commit.precommits[0].signature =
-		sp_core::crypto::UncheckedFrom::unchecked_from([1u8; 64]);
-
-	assert_eq!(
-		verify_justification::<TestHeader>(
-			header_id::<TestHeader>(1),
-			TEST_GRANDPA_SET_ID,
-			&voter_set(),
-			&justification,
-		),
-		Err(Error::InvalidAuthoritySignature),
-	);
-}
-
-#[test]
-fn justification_with_invalid_precommit_ancestry() {
-	let mut justification = make_default_justification::<TestHeader>(&test_header(1));
-	justification.votes_ancestries.push(test_header(10));
-
-	assert_eq!(
-		verify_justification::<TestHeader>(
-			header_id::<TestHeader>(1),
-			TEST_GRANDPA_SET_ID,
-			&voter_set(),
-			&justification,
-		),
-		Err(Error::RedundantVotesAncestries),
-	);
-}
-
-#[test]
-fn justification_is_invalid_if_we_dont_meet_threshold() {
-	// Need at least three authorities to sign off or else the voter set threshold can't be reached
-	let authorities = vec![(ALICE, 1), (BOB, 1)];
-
-	let params = JustificationGeneratorParams {
-		header: test_header(1),
-		round: TEST_GRANDPA_ROUND,
-		set_id: TEST_GRANDPA_SET_ID,
-		authorities: authorities.clone(),
-		ancestors: 2 * authorities.len() as u32,
-		forks: 2,
-	};
-
-	assert_eq!(
-		verify_justification::<TestHeader>(
-			header_id::<TestHeader>(1),
-			TEST_GRANDPA_SET_ID,
-			&voter_set(),
-			&make_justification_for_header::<TestHeader>(params)
-		),
-		Err(Error::TooLowCumulativeWeight),
-	);
-}
-
 #[test]
 fn optimizer_does_noting_with_minimal_justification() {
 	let mut justification = make_default_justification::<TestHeader>(&test_header(1));

cumulus/bridges/primitives/header-chain/tests/justification/strict.rs

@@ -0,0 +1,196 @@
+// Copyright 2020-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/>.
+
+//! Tests for Grandpa strict justification verifier code.
+
+use bp_header_chain::justification::{
+	required_justification_precommits, verify_justification, JustificationVerificationError,
+	PrecommitError,
+};
+use bp_test_utils::*;
+
+type TestHeader = sp_runtime::testing::Header;
+
+#[test]
+fn valid_justification_accepted() {
+	let authorities = vec![(ALICE, 1), (BOB, 1), (CHARLIE, 1)];
+	let params = JustificationGeneratorParams {
+		header: test_header(1),
+		round: TEST_GRANDPA_ROUND,
+		set_id: TEST_GRANDPA_SET_ID,
+		authorities: authorities.clone(),
+		ancestors: 7,
+		forks: 3,
+	};
+
+	let justification = make_justification_for_header::<TestHeader>(params.clone());
+	assert_eq!(
+		verify_justification::<TestHeader>(
+			header_id::<TestHeader>(1),
+			TEST_GRANDPA_SET_ID,
+			&voter_set(),
+			&justification,
+		),
+		Ok(()),
+	);
+
+	assert_eq!(justification.commit.precommits.len(), authorities.len());
+	assert_eq!(justification.votes_ancestries.len(), params.ancestors as usize);
+}
+
+#[test]
+fn valid_justification_accepted_with_single_fork() {
+	let params = JustificationGeneratorParams {
+		header: test_header(1),
+		round: TEST_GRANDPA_ROUND,
+		set_id: TEST_GRANDPA_SET_ID,
+		authorities: vec![(ALICE, 1), (BOB, 1), (CHARLIE, 1)],
+		ancestors: 5,
+		forks: 1,
+	};
+
+	assert_eq!(
+		verify_justification::<TestHeader>(
+			header_id::<TestHeader>(1),
+			TEST_GRANDPA_SET_ID,
+			&voter_set(),
+			&make_justification_for_header::<TestHeader>(params)
+		),
+		Ok(()),
+	);
+}
+
+#[test]
+fn valid_justification_accepted_with_arbitrary_number_of_authorities() {
+	use finality_grandpa::voter_set::VoterSet;
+	use sp_consensus_grandpa::AuthorityId;
+
+	let n = 15;
+	let required_signatures = required_justification_precommits(n as _);
+	let authorities = accounts(n).iter().map(|k| (*k, 1)).collect::<Vec<_>>();
+
+	let params = JustificationGeneratorParams {
+		header: test_header(1),
+		round: TEST_GRANDPA_ROUND,
+		set_id: TEST_GRANDPA_SET_ID,
+		authorities: authorities.clone().into_iter().take(required_signatures as _).collect(),
+		ancestors: n.into(),
+		forks: required_signatures,
+	};
+
+	let authorities = authorities
+		.iter()
+		.map(|(id, w)| (AuthorityId::from(*id), *w))
+		.collect::<Vec<(AuthorityId, _)>>();
+	let voter_set = VoterSet::new(authorities).unwrap();
+
+	assert_eq!(
+		verify_justification::<TestHeader>(
+			header_id::<TestHeader>(1),
+			TEST_GRANDPA_SET_ID,
+			&voter_set,
+			&make_justification_for_header::<TestHeader>(params)
+		),
+		Ok(()),
+	);
+}
+
+#[test]
+fn justification_with_invalid_target_rejected() {
+	assert_eq!(
+		verify_justification::<TestHeader>(
+			header_id::<TestHeader>(2),
+			TEST_GRANDPA_SET_ID,
+			&voter_set(),
+			&make_default_justification::<TestHeader>(&test_header(1)),
+		),
+		Err(JustificationVerificationError::InvalidJustificationTarget),
+	);
+}
+
+#[test]
+fn justification_with_invalid_commit_rejected() {
+	let mut justification = make_default_justification::<TestHeader>(&test_header(1));
+	justification.commit.precommits.clear();
+
+	assert_eq!(
+		verify_justification::<TestHeader>(
+			header_id::<TestHeader>(1),
+			TEST_GRANDPA_SET_ID,
+			&voter_set(),
+			&justification,
+		),
+		Err(JustificationVerificationError::TooLowCumulativeWeight),
+	);
+}
+
+#[test]
+fn justification_with_invalid_authority_signature_rejected() {
+	let mut justification = make_default_justification::<TestHeader>(&test_header(1));
+	justification.commit.precommits[0].signature =
+		sp_core::crypto::UncheckedFrom::unchecked_from([1u8; 64]);
+
+	assert_eq!(
+		verify_justification::<TestHeader>(
+			header_id::<TestHeader>(1),
+			TEST_GRANDPA_SET_ID,
+			&voter_set(),
+			&justification,
+		),
+		Err(JustificationVerificationError::Precommit(PrecommitError::InvalidAuthoritySignature)),
+	);
+}
+
+#[test]
+fn justification_with_invalid_precommit_ancestry() {
+	let mut justification = make_default_justification::<TestHeader>(&test_header(1));
+	justification.votes_ancestries.push(test_header(10));
+
+	assert_eq!(
+		verify_justification::<TestHeader>(
+			header_id::<TestHeader>(1),
+			TEST_GRANDPA_SET_ID,
+			&voter_set(),
+			&justification,
+		),
+		Err(JustificationVerificationError::RedundantVotesAncestries),
+	);
+}
+
+#[test]
+fn justification_is_invalid_if_we_dont_meet_threshold() {
+	// Need at least three authorities to sign off or else the voter set threshold can't be reached
+	let authorities = vec![(ALICE, 1), (BOB, 1)];
+
+	let params = JustificationGeneratorParams {
+		header: test_header(1),
+		round: TEST_GRANDPA_ROUND,
+		set_id: TEST_GRANDPA_SET_ID,
+		authorities: authorities.clone(),
+		ancestors: 2 * authorities.len() as u32,
+		forks: 2,
+	};
+
+	assert_eq!(
+		verify_justification::<TestHeader>(
+			header_id::<TestHeader>(1),
+			TEST_GRANDPA_SET_ID,
+			&voter_set(),
+			&make_justification_for_header::<TestHeader>(params)
+		),
+		Err(JustificationVerificationError::TooLowCumulativeWeight),
+	);
+}

cumulus/bridges/primitives/header-chain/tests/tests.rs

@@ -0,0 +1,7 @@
+mod justification {
+	mod equivocation;
+	mod optimizer;
+	mod strict;
+}
+
+mod implementation_match;