grandpa: report equivocations (#3868)

* session: runtime api for generating session membership proofs * grandpa: add runtime api for creating equivocation report txs * grandpa: submit signed equivocation report transactions * grandpa: use proper equivocation report type * grandpa: report equivocations * grandpa: validate equivocation proof * grandpa: update to finality-grandpa 0.9.1 * grandpa: fix encoding of session membership proof * grandpa: initialize set id session mapping for genesis session * grandpa: fix bug in set_id session validation * fix compilation * cleanup from merge conflicts * cleanup crate tomls * grandpa: refactor equivocation handling to separate trait * node-template: fix compilation * fix test compilation * bump finality-grandpa to v0.10.2 * rpc: fix runtime version test * CHERRY-PICK #4200: Add documentation to SubmitSignedTransaction and actually make it work Squashed commit of the following: commit 4f2cb0b1c588a06f2f3b478bb4b28b5cb29d54b9 Author: Tomasz Drwięga <tomasz@parity.io> Date: Tue Dec 3 16:29:33 2019 +0100 Split the method to avoid confusing type error message. commit c5bf24eeaaf902add89ed1b046b22c4a4aaeb2cd Author: Tomasz Drwięga <tomasz@parity.io> Date: Tue Dec 3 16:19:55 2019 +0100 Make accounts optional, fix logic. commit 97db1ef556e023cf6847e5ffdb036c0e3ea6fb0a Author: Tomasz Drwięga <tomasz@parity.io> Date: Tue Dec 3 10:06:20 2019 +0100 Remove warning. commit 535f5c116d1a2e826eaf90c3f7e6798e443d61d8 Merge: 516257217 0f1a5f651 Author: Tomasz Drwięga <tomasz@parity.io> Date: Tue Dec 3 07:08:05 2019 +0100 Merge branch 'master' into td-signed-transactions commit 516257217bac89fcebd083712f4ea68b7b23b55a Merge: ac98248c6 2e68c80c2 Author: Tomasz Drwięga <tomasz@parity.io> Date: Mon Dec 2 13:57:25 2019 +0100 Merge branch 'master' into td-signed-transactions commit ac98248c6c56cff381130645a82a13d29933cf83 Author: Tomasz Drwięga <tomasz@parity.io> Date: Mon Nov 25 17:34:52 2019 +0100 Forgotten import. commit 67a3c19031506c28e31c6bc4a90fff62d467dd58 Author: Tomasz Drwięga <tomasz@parity.io> Date: Mon Nov 25 17:32:10 2019 +0100 Fix naming and bounds. commit 93e768ea9df97a4629fca1f9bc4b108fdb33f876 Author: Tomasz Drwięga <tomasz@parity.io> Date: Mon Nov 25 17:01:05 2019 +0100 Add documentation to signed transactions and actually make them work. * grandpa: skip block initialization on report submission method * primitives: allow transaction pool access by default for offchain calls * grandpa: unused parameters * grandpa: remove unused method * grandpa: enable equivocation reporting * grandpa: add workaround for parameter encoding * grandpa: fix localized_payload calls in tests * fix submit_report_equivocation_extrinsic in runtimes * node: fix submit transaction test compilation * node: bump spec_version * rpc: fix api version test * grandpa: allow custom equivocation offence type * grandpa: add test for authorities::next_change_height * grandpa: cleanup report_equivocation function * node: move reporting app crypto to node-primitives * grandpa: move equivocation traits to own module * grandpa: rename app-crypto crate import * grandpa: export equivocation types * node: bump spec_version * grandpa: rename EquivocationReport to EquivocationProof * grandpa: add missing docs to primitives * grandpa: add missing docs to equivocation * node: fix compilation * grandpa: add missing docs to pallet * node: bump spec_version * fix whitespace * grandpa: return error on offence reporting * grandpa: expose session and validator count in proofs through traits * grandpa: use strong key in module KeyOwnerProofSystem * grandpa: move key ownership proof to grandpa runtime api * grandpa: remove unnecessary cloning when checking equivocation proof * grandpa: make report_equivocation a method in Environment * support: implement KeyOwnerProofSystem for () * grandpa: move KeyOwnerProofSystem to module trait * test-utils: fix runtime compilation * grandpa: fix test compilation * grandpa: fix test compilation after merge * grandpa: simplify transaction submission types * grandpa: validate equivocation report in signed extension * client: fix test * node: use ValidateEquivocationReport signed extension * grandpa: expose key ownership proof under opaque type * grandpa: better docs on key ownership proofs * grandpa: add note about signed extension * grandpa: add ValidateEquivocationReport::new * grandpa: remove skip_initialize_block from runtime api * grandpa: use new offchain transaction submission API * grandpa: take set_id in generate_key_ownership_proof * grandpa: update to finality-grandpa v0.12.2 * grandpa: cleanup usages of AuthoritySet::current * grandpa: fix test * grandpa: add mocking utilities for equivocation reporting * grandpa: add test for equivocation reporting * grandpa: move SetIdSession initialization * grandpa: add more tests * node: enable historical session manager * node: bump spec_version * node: use strong key types in KeyOwnerProofSystem definitions * grandpa: export GrandpaEquivocationOffence type
2026-05-06 02:08:02 +00:00 · 2020-05-06 17:25:51 +01:00
parent a1127f8f9d
commit fbd2ac8f3b
38 changed files with 2249 additions and 296 deletions
@@ -100,15 +100,17 @@ pub(crate) struct Status<H, N> {
 /// A set of authorities.
 #[derive(Debug, Clone, Encode, Decode, PartialEq)]
 pub(crate) struct AuthoritySet<H, N> {
+	/// The current active authorities.
 	pub(crate) current_authorities: AuthorityList,
-	set_id: u64,
-	// Tree of pending standard changes across forks. Standard changes are
-	// enacted on finality and must be enacted (i.e. finalized) in-order across
-	// a given branch
+	/// The current set id.
+	pub(crate) set_id: u64,
+	/// Tree of pending standard changes across forks. Standard changes are
+	/// enacted on finality and must be enacted (i.e. finalized) in-order across
+	/// a given branch
 	pub(crate) pending_standard_changes: ForkTree<H, N, PendingChange<H, N>>,
-	// Pending forced changes across different forks (at most one per fork).
-	// Forced changes are enacted on block depth (not finality), for this reason
-	// only one forced change should exist per fork.
+	/// Pending forced changes across different forks (at most one per fork).
+	/// Forced changes are enacted on block depth (not finality), for this reason
+	/// only one forced change should exist per fork.
 	pending_forced_changes: Vec<PendingChange<H, N>>,
 }

@@ -162,9 +164,55 @@ where H: PartialEq,

 impl<H: Eq, N> AuthoritySet<H, N>
 where
-	N: Add<Output=N> + Ord + Clone + Debug,
-	H: Clone + Debug
+	N: Add<Output = N> + Ord + Clone + Debug,
+	H: Clone + Debug,
 {
+	/// Returns the block hash and height at which the next pending change in
+	/// the given chain (i.e. it includes `best_hash`) was signalled, `None` if
+	/// there are no pending changes for the given chain.
+	///
+	/// This is useful since we know that when a change is signalled the
+	/// underlying runtime authority set management module (e.g. session module)
+	/// has updated its internal state (e.g. a new session started).
+	pub(crate) fn next_change<F, E>(
+		&self,
+		best_hash: &H,
+		is_descendent_of: &F,
+	) -> Result<Option<(H, N)>, fork_tree::Error<E>>
+	where
+		F: Fn(&H, &H) -> Result<bool, E>,
+		E: std::error::Error,
+	{
+		let mut forced = None;
+		for change in &self.pending_forced_changes {
+			if is_descendent_of(&change.canon_hash, best_hash)? {
+				forced = Some((change.canon_hash.clone(), change.canon_height.clone()));
+				break;
+			}
+		}
+
+		let mut standard = None;
+		for (_, _, change) in self.pending_standard_changes.roots() {
+			if is_descendent_of(&change.canon_hash, best_hash)? {
+				standard = Some((change.canon_hash.clone(), change.canon_height.clone()));
+				break;
+			}
+		}
+
+		let earliest = match (forced, standard) {
+			(Some(forced), Some(standard)) => Some(if forced.1 < standard.1 {
+				forced
+			} else {
+				standard
+			}),
+			(Some(forced), None) => Some(forced),
+			(None, Some(standard)) => Some(standard),
+			(None, None) => None,
+		};
+
+		Ok(earliest)
+	}
+
 	fn add_standard_change<F, E>(
 		&mut self,
 		pending: PendingChange<H, N>,
@@ -922,6 +970,128 @@ mod tests {
 		);
 	}

+	#[test]
+	fn next_change_works() {
+		let current_authorities = vec![(AuthorityId::from_slice(&[1; 32]), 1)];
+
+		let mut authorities = AuthoritySet {
+			current_authorities: current_authorities.clone(),
+			set_id: 0,
+			pending_standard_changes: ForkTree::new(),
+			pending_forced_changes: Vec::new(),
+		};
+
+		let new_set = current_authorities.clone();
+
+		// We have three pending changes with 2 possible roots that are enacted
+		// immediately on finality (i.e. standard changes).
+		let change_a0 = PendingChange {
+			next_authorities: new_set.clone(),
+			delay: 0,
+			canon_height: 5,
+			canon_hash: "hash_a0",
+			delay_kind: DelayKind::Finalized,
+		};
+
+		let change_a1 = PendingChange {
+			next_authorities: new_set.clone(),
+			delay: 0,
+			canon_height: 10,
+			canon_hash: "hash_a1",
+			delay_kind: DelayKind::Finalized,
+		};
+
+		let change_b = PendingChange {
+			next_authorities: new_set.clone(),
+			delay: 0,
+			canon_height: 4,
+			canon_hash: "hash_b",
+			delay_kind: DelayKind::Finalized,
+		};
+
+		// A0 (#5) <- A10 (#8) <- A1 (#10) <- best_a
+		// B (#4) <- best_b
+		let is_descendent_of = is_descendent_of(|base, hash| match (*base, *hash) {
+			("hash_a0", "hash_a1") => true,
+			("hash_a0", "best_a") => true,
+			("hash_a1", "best_a") => true,
+			("hash_a10", "best_a") => true,
+			("hash_b", "best_b") => true,
+			_ => false,
+		});
+
+		// add the three pending changes
+		authorities
+			.add_pending_change(change_b, &is_descendent_of)
+			.unwrap();
+		authorities
+			.add_pending_change(change_a0, &is_descendent_of)
+			.unwrap();
+		authorities
+			.add_pending_change(change_a1, &is_descendent_of)
+			.unwrap();
+
+		// the earliest change at block `best_a` should be the change at A0 (#5)
+		assert_eq!(
+			authorities
+				.next_change(&"best_a", &is_descendent_of)
+				.unwrap(),
+			Some(("hash_a0", 5)),
+		);
+
+		// the earliest change at block `best_b` should be the change at B (#4)
+		assert_eq!(
+			authorities
+				.next_change(&"best_b", &is_descendent_of)
+				.unwrap(),
+			Some(("hash_b", 4)),
+		);
+
+		// we apply the change at A0 which should prune it and the fork at B
+		authorities
+			.apply_standard_changes("hash_a0", 5, &is_descendent_of, false)
+			.unwrap();
+
+		// the next change is now at A1 (#10)
+		assert_eq!(
+			authorities
+				.next_change(&"best_a", &is_descendent_of)
+				.unwrap(),
+			Some(("hash_a1", 10)),
+		);
+
+		// there's no longer any pending change at `best_b` fork
+		assert_eq!(
+			authorities
+				.next_change(&"best_b", &is_descendent_of)
+				.unwrap(),
+			None,
+		);
+
+		// we a forced change at A10 (#8)
+		let change_a10 = PendingChange {
+			next_authorities: new_set.clone(),
+			delay: 0,
+			canon_height: 8,
+			canon_hash: "hash_a10",
+			delay_kind: DelayKind::Best {
+				median_last_finalized: 0,
+			},
+		};
+
+		authorities
+			.add_pending_change(change_a10, &static_is_descendent_of(false))
+			.unwrap();
+
+		// it should take precedence over the change at A1 (#10)
+		assert_eq!(
+			authorities
+				.next_change(&"best_a", &is_descendent_of)
+				.unwrap(),
+			Some(("hash_a10", 8)),
+		);
+	}
+
 	#[test]
 	fn maintains_authority_list_invariants() {
 		// empty authority lists are invalid
@@ -154,7 +154,7 @@ fn migrate_from_version0<Block: BlockT, B, G>(
 			None => (0, genesis_round()),
 		};

-		let set_id = new_set.current().0;
+		let set_id = new_set.set_id;

 		let base = last_round_state.prevote_ghost
 			.expect("state is for completed round; completed rounds must have a prevote ghost; qed.");
@@ -201,7 +201,7 @@ fn migrate_from_version1<Block: BlockT, B, G>(
 		backend,
 		AUTHORITY_SET_KEY,
 	)? {
-		let set_id = set.current().0;
+		let set_id = set.set_id;

 		let completed_rounds = |number, state, base| CompletedRounds::new(
 			CompletedRound {
@@ -312,7 +312,7 @@ pub(crate) fn load_persistent<Block: BlockT, B, G>(
 							.expect("state is for completed round; completed rounds must have a prevote ghost; qed.");

 						VoterSetState::live(
-							set.current().0,
+							set.set_id,
 							&set,
 							base,
 						)
@@ -814,7 +814,7 @@ impl<Block: BlockT> Inner<Block> {
 			return Action::Discard(cost::UNKNOWN_VOTER);
 		}

-		if let Err(()) = super::check_message_sig::<Block>(
+		if let Err(()) = sp_finality_grandpa::check_message_signature(
 			&full.message.message,
 			&full.message.id,
 			&full.message.signature,
@@ -610,30 +610,6 @@ impl<B: BlockT, N: Network<B>> Clone for NetworkBridge<B, N> {
 	}
 }

-/// Encode round message localized to a given round and set id.
-pub(crate) fn localized_payload<E: Encode>(
-	round: RoundNumber,
-	set_id: SetIdNumber,
-	message: &E,
-) -> Vec<u8> {
-	let mut buf = Vec::new();
-	localized_payload_with_buffer(round, set_id, message, &mut buf);
-	buf
-}
-
-/// Encode round message localized to a given round and set id using the given
-/// buffer. The given buffer will be cleared and the resulting encoded payload
-/// will always be written to the start of the buffer.
-pub(crate) fn localized_payload_with_buffer<E: Encode>(
-	round: RoundNumber,
-	set_id: SetIdNumber,
-	message: &E,
-	buf: &mut Vec<u8>,
-) {
-	buf.clear();
-	(message, round, set_id).encode_to(buf)
-}
-
 /// Type-safe wrapper around a round number.
 #[derive(Debug, Clone, Copy, Eq, PartialEq, PartialOrd, Ord, Encode, Decode)]
 pub struct Round(pub RoundNumber);
@@ -642,48 +618,6 @@ pub struct Round(pub RoundNumber);
 #[derive(Debug, Clone, Copy, Eq, PartialEq, PartialOrd, Ord, Encode, Decode)]
 pub struct SetId(pub SetIdNumber);

-/// Check a message signature by encoding the message as a localized payload and
-/// verifying the provided signature using the expected authority id.
-pub(crate) fn check_message_sig<Block: BlockT>(
-	message: &Message<Block>,
-	id: &AuthorityId,
-	signature: &AuthoritySignature,
-	round: RoundNumber,
-	set_id: SetIdNumber,
-) -> Result<(), ()> {
-	check_message_sig_with_buffer::<Block>(
-		message,
-		id,
-		signature,
-		round,
-		set_id,
-		&mut Vec::new(),
-	)
-}
-
-/// Check a message signature by encoding the message as a localized payload and
-/// verifying the provided signature using the expected authority id.
-/// The encoding necessary to verify the signature will be done using the given
-/// buffer, the original content of the buffer will be cleared.
-pub(crate) fn check_message_sig_with_buffer<Block: BlockT>(
-	message: &Message<Block>,
-	id: &AuthorityId,
-	signature: &AuthoritySignature,
-	round: RoundNumber,
-	set_id: SetIdNumber,
-	buf: &mut Vec<u8>,
-) -> Result<(), ()> {
-	let as_public = id.clone();
-	localized_payload_with_buffer(round, set_id, message, buf);
-
-	if AuthorityPair::verify(signature, buf, &as_public) {
-		Ok(())
-	} else {
-		debug!(target: "afg", "Bad signature on message from {:?}", id);
-		Err(())
-	}
-}
-
 /// A sink for outgoing messages to the network. Any messages that are sent will
 /// be replaced, as appropriate, according to the given `HasVoted`.
 /// NOTE: The votes are stored unsigned, which means that the signatures need to
@@ -731,16 +665,14 @@ impl<Block: BlockT> Sink<Message<Block>> for OutgoingMessages<Block>
 		}

 		// when locals exist, sign messages on import
-		if let Some((ref pair, ref local_id)) = self.locals {
-			let encoded = localized_payload(self.round, self.set_id, &msg);
-			let signature = pair.sign(&encoded[..]);
-
+		if let Some((ref pair, _)) = self.locals {
 			let target_hash = msg.target().0.clone();
-			let signed = SignedMessage::<Block> {
-				message: msg,
-				signature,
-				id: local_id.clone(),
-			};
+			let signed = sp_finality_grandpa::sign_message(
+				msg,
+				pair,
+				self.round,
+				self.set_id,
+			);

 			let message = GossipMessage::Vote(VoteMessage::<Block> {
 				message: signed.clone(),
@@ -828,7 +760,7 @@ fn check_compact_commit<Block: BlockT>(
 		use crate::communication::gossip::Misbehavior;
 		use finality_grandpa::Message as GrandpaMessage;

-		if let Err(()) = check_message_sig_with_buffer::<Block>(
+		if let Err(()) = sp_finality_grandpa::check_message_signature_with_buffer(
 			&GrandpaMessage::Precommit(precommit.clone()),
 			id,
 			sig,
@@ -916,7 +848,7 @@ fn check_catch_up<Block: BlockT>(
 		for (msg, id, sig) in messages {
 			signatures_checked += 1;

-			if let Err(()) = check_message_sig_with_buffer::<B>(
+			if let Err(()) = sp_finality_grandpa::check_message_signature_with_buffer(
 				&msg,
 				id,
 				sig,
@@ -226,7 +226,7 @@ fn good_commit_leads_to_relay() {
 		let target_number = 500;

 		let precommit = finality_grandpa::Precommit { target_hash: target_hash.clone(), target_number };
-		let payload = super::localized_payload(
+		let payload = sp_finality_grandpa::localized_payload(
 			round, set_id, &finality_grandpa::Message::Precommit(precommit.clone())
 		);

@@ -374,7 +374,7 @@ fn bad_commit_leads_to_report() {
 		let target_number = 500;

 		let precommit = finality_grandpa::Precommit { target_hash: target_hash.clone(), target_number };
-		let payload = super::localized_payload(
+		let payload = sp_finality_grandpa::localized_payload(
 			round, set_id, &finality_grandpa::Message::Precommit(precommit.clone())
 		);

@@ -25,14 +25,14 @@ use parity_scale_codec::{Decode, Encode};
 use futures::prelude::*;
 use futures_timer::Delay;
 use parking_lot::RwLock;
-use sp_blockchain::{HeaderBackend, Error as ClientError, HeaderMetadata};
 use std::marker::PhantomData;

 use sc_client_api::{backend::{Backend, apply_aux}, utils::is_descendent_of};
 use finality_grandpa::{
-	BlockNumberOps, Equivocation, Error as GrandpaError, round::State as RoundState,
+	BlockNumberOps, Error as GrandpaError, round::State as RoundState,
 	voter, voter_set::VoterSet,
 };
+use sp_blockchain::{HeaderBackend, HeaderMetadata, Error as ClientError};
 use sp_core::Pair;
 use sp_runtime::generic::BlockId;
 use sp_runtime::traits::{
@@ -53,7 +53,10 @@ use crate::consensus_changes::SharedConsensusChanges;
 use crate::justification::GrandpaJustification;
 use crate::until_imported::UntilVoteTargetImported;
 use crate::voting_rule::VotingRule;
-use sp_finality_grandpa::{AuthorityId, AuthoritySignature, SetId, RoundNumber};
+use sp_finality_grandpa::{
+	AuthorityId, AuthoritySignature, Equivocation, EquivocationProof,
+	GrandpaApi, RoundNumber, SetId,
+};
 use prometheus_endpoint::{Gauge, U64, register, PrometheusError};

 type HistoricalVotes<Block> = finality_grandpa::HistoricalVotes<
@@ -124,7 +127,7 @@ impl<Block: BlockT> CompletedRounds<Block> {
 		let mut rounds = Vec::with_capacity(NUM_LAST_COMPLETED_ROUNDS);
 		rounds.push(genesis);

-		let voters = voters.current().1.iter().map(|(a, _)| a.clone()).collect();
+		let voters = voters.current_authorities.iter().map(|(a, _)| a.clone()).collect();
 		CompletedRounds { rounds, set_id, voters }
 	}

@@ -403,7 +406,7 @@ pub(crate) struct Environment<Backend, Block: BlockT, C, N: NetworkT<Block>, SC,
 	pub(crate) _phantom: PhantomData<Backend>,
 }

-impl<Backend, Block: BlockT, C, N: NetworkT<Block>, SC, VR> Environment<Backend, Block, C, N, SC, VR> {
+impl<BE, Block: BlockT, C, N: NetworkT<Block>, SC, VR> Environment<BE, Block, C, N, SC, VR> {
 	/// Updates the voter set state using the given closure. The write lock is
 	/// held during evaluation of the closure and the environment's voter set
 	/// state is set to its result if successful.
@@ -430,6 +433,98 @@ impl<Backend, Block: BlockT, C, N: NetworkT<Block>, SC, VR> Environment<Backend,
 	}
 }

+impl<BE, Block, C, N, SC, VR> Environment<BE, Block, C, N, SC, VR>
+where
+	Block: BlockT,
+	BE: Backend<Block>,
+	C: crate::ClientForGrandpa<Block, BE>,
+	C::Api: GrandpaApi<Block, Error = sp_blockchain::Error>,
+	N: NetworkT<Block>,
+	SC: SelectChain<Block> + 'static,
+{
+	/// Report the given equivocation to the GRANDPA runtime module. This method
+	/// generates a session membership proof of the offender and then submits an
+	/// extrinsic to report the equivocation. In particular, the session membership
+	/// proof must be generated at the block at which the given set was active which
+	/// isn't necessarily the best block if there are pending authority set changes.
+	fn report_equivocation(
+		&self,
+		equivocation: Equivocation<Block::Hash, NumberFor<Block>>,
+	) -> Result<(), Error> {
+		let is_descendent_of = is_descendent_of(&*self.client, None);
+
+		let best_header = self.select_chain
+			.best_chain()
+			.map_err(|e| Error::Blockchain(e.to_string()))?;
+
+		let authority_set = self.authority_set.inner().read();
+
+		// block hash and number of the next pending authority set change in the
+		// given best chain.
+		let next_change = authority_set
+			.next_change(&best_header.hash(), &is_descendent_of)
+			.map_err(|e| Error::Safety(e.to_string()))?;
+
+		// find the hash of the latest block in the current set
+		let current_set_latest_hash = match next_change {
+			Some((_, n)) if n.is_zero() => {
+				return Err(Error::Safety(
+					"Authority set change signalled at genesis.".to_string(),
+				))
+			}
+			// the next set starts at `n` so the current one lasts until `n - 1`. if
+			// `n` is later than the best block, then the current set is still live
+			// at best block.
+			Some((_, n)) if n > *best_header.number() => best_header.hash(),
+			Some((h, _)) => {
+				// this is the header at which the new set will start
+				let header = self.client.header(BlockId::Hash(h))?.expect(
+					"got block hash from registered pending change; \
+					 pending changes are only registered on block import; qed.",
+				);
+
+				// its parent block is the last block in the current set
+				*header.parent_hash()
+			}
+			// there is no pending change, the latest block for the current set is
+			// the best block.
+			None => best_header.hash(),
+		};
+
+		// generate key ownership proof at that block
+		let key_owner_proof = match self.client
+			.runtime_api()
+			.generate_key_ownership_proof(
+				&BlockId::Hash(current_set_latest_hash),
+				authority_set.set_id,
+				equivocation.offender().clone(),
+			)
+			.map_err(Error::Client)?
+		{
+			Some(proof) => proof,
+			None => {
+				debug!(target: "afg", "Equivocation offender is not part of the authority set.");
+				return Ok(());
+			}
+		};
+
+		// submit equivocation report at **best** block
+		let equivocation_proof = EquivocationProof::new(
+			authority_set.set_id,
+			equivocation,
+		);
+
+		self.client.runtime_api()
+			.submit_report_equivocation_extrinsic(
+				&BlockId::Hash(best_header.hash()),
+				equivocation_proof,
+				key_owner_proof,
+			).map_err(Error::Client)?;
+
+		Ok(())
+	}
+}
+
 impl<BE, Block: BlockT, C, N, SC, VR>
 	finality_grandpa::Chain<Block::Hash, NumberFor<Block>>
 for Environment<BE, Block, C, N, SC, VR>
@@ -437,7 +532,7 @@ where
 	Block: 'static,
 	BE: Backend<Block>,
 	C: crate::ClientForGrandpa<Block, BE>,
- 	N: NetworkT<Block> + 'static + Send,
+	N: NetworkT<Block> + 'static + Send,
 	SC: SelectChain<Block> + 'static,
 	VR: VotingRule<Block, C>,
 	NumberFor<Block>: BlockNumberOps,
@@ -451,7 +546,7 @@ where
 		//       signaled asynchronously. therefore the voter could still vote in the next round
 		//       before activating the new set. the `authority_set` is updated immediately thus we
 		//       restrict the voter based on that.
-		if self.set_id != self.authority_set.inner().read().current().0 {
+		if self.set_id != self.authority_set.set_id() {
 			return None;
 		}

@@ -579,7 +674,8 @@ where
 	Block: 'static,
 	B: Backend<Block>,
 	C: crate::ClientForGrandpa<Block, B> + 'static,
-	N: NetworkT<Block> + 'static + Send + Sync,
+	C::Api: GrandpaApi<Block, Error = sp_blockchain::Error>,
+ 	N: NetworkT<Block> + 'static + Send + Sync,
 	SC: SelectChain<Block> + 'static,
 	VR: VotingRule<Block, C>,
 	NumberFor<Block>: BlockNumberOps,
@@ -925,19 +1021,23 @@ where
 	fn prevote_equivocation(
 		&self,
 		_round: RoundNumber,
-		equivocation: ::finality_grandpa::Equivocation<Self::Id, Prevote<Block>, Self::Signature>
+		equivocation: finality_grandpa::Equivocation<Self::Id, Prevote<Block>, Self::Signature>,
 	) {
 		warn!(target: "afg", "Detected prevote equivocation in the finality worker: {:?}", equivocation);
-		// nothing yet; this could craft misbehavior reports of some kind.
+		if let Err(err) = self.report_equivocation(equivocation.into()) {
+			warn!(target: "afg", "Error reporting prevote equivocation: {:?}", err);
+		}
 	}

 	fn precommit_equivocation(
 		&self,
 		_round: RoundNumber,
-		equivocation: Equivocation<Self::Id, Precommit<Block>, Self::Signature>
+		equivocation: finality_grandpa::Equivocation<Self::Id, Precommit<Block>, Self::Signature>,
 	) {
 		warn!(target: "afg", "Detected precommit equivocation in the finality worker: {:?}", equivocation);
-		// nothing yet
+		if let Err(err) = self.report_equivocation(equivocation.into()) {
+			warn!(target: "afg", "Error reporting precommit equivocation: {:?}", err);
+		}
 	}
 }

@@ -26,7 +26,6 @@ use sp_runtime::traits::{NumberFor, Block as BlockT, Header as HeaderT};
 use sp_finality_grandpa::AuthorityId;

 use crate::{Commit, Error};
-use crate::communication;

 /// A GRANDPA justification for block finality, it includes a commit message and
 /// an ancestry proof including all headers routing all precommit target blocks
@@ -132,7 +131,7 @@ impl<Block: BlockT> GrandpaJustification<Block> {
 		let mut buf = Vec::new();
 		let mut visited_hashes = HashSet::new();
 		for signed in self.commit.precommits.iter() {
-			if let Err(_) = communication::check_message_sig_with_buffer::<Block>(
+			if let Err(_) = sp_finality_grandpa::check_message_signature_with_buffer(
 				&finality_grandpa::Message::Precommit(signed.precommit.clone()),
 				&signed.id,
 				&signed.signature,
@@ -62,9 +62,10 @@ use sc_client_api::{
 	LockImportRun, BlockchainEvents, CallExecutor,
 	ExecutionStrategy, Finalizer, TransactionFor, ExecutorProvider,
 };
-use sp_blockchain::{HeaderBackend, Error as ClientError, HeaderMetadata};
 use parity_scale_codec::{Decode, Encode};
 use prometheus_endpoint::{PrometheusError, Registry};
+use sp_api::ProvideRuntimeApi;
+use sp_blockchain::{HeaderBackend, Error as ClientError, HeaderMetadata};
 use sp_runtime::generic::BlockId;
 use sp_runtime::traits::{NumberFor, Block as BlockT, DigestFor, Zero};
 use sc_keystore::KeyStorePtr;
@@ -134,8 +135,7 @@ use communication::{NetworkBridge, Network as NetworkT};
 use sp_finality_grandpa::{AuthorityList, AuthorityPair, AuthoritySignature, SetId};

 // Re-export these two because it's just so damn convenient.
-pub use sp_finality_grandpa::{AuthorityId, ScheduledChange};
-use sp_api::ProvideRuntimeApi;
+pub use sp_finality_grandpa::{AuthorityId, GrandpaApi, ScheduledChange};
 use std::marker::PhantomData;

 #[cfg(test)]
@@ -143,6 +143,7 @@ mod tests;

 /// A GRANDPA message for a substrate chain.
 pub type Message<Block> = finality_grandpa::Message<<Block as BlockT>::Hash, NumberFor<Block>>;
+
 /// A signed message.
 pub type SignedMessage<Block> = finality_grandpa::SignedMessage<
 	<Block as BlockT>::Hash,
@@ -687,6 +688,7 @@ pub fn run_grandpa_voter<Block: BlockT, BE: 'static, C, N, SC, VR>(
 	NumberFor<Block>: BlockNumberOps,
 	DigestFor<Block>: Encode,
 	C: ClientForGrandpa<Block, BE> + 'static,
+	C::Api: GrandpaApi<Block, Error = sp_blockchain::Error>,
 {
 	let GrandpaParams {
 		mut config,
@@ -802,6 +804,7 @@ where
 	Block: BlockT,
 	B: Backend<Block> + 'static,
 	C: ClientForGrandpa<Block, B> + 'static,
+	C::Api: GrandpaApi<Block, Error = sp_blockchain::Error>,
 	N: NetworkT<Block> + Sync,
 	NumberFor<Block>: BlockNumberOps,
 	SC: SelectChain<Block> + 'static,
@@ -971,7 +974,6 @@ where
 					voters,
 					set_id: new.set_id,
 					voter_set_state: self.env.voter_set_state.clone(),
-					// Fields below are simply transferred and not updated.
 					client: self.env.client.clone(),
 					select_chain: self.env.select_chain.clone(),
 					config: self.env.config.clone(),
@@ -1013,6 +1015,7 @@ where
 	NumberFor<Block>: BlockNumberOps,
 	SC: SelectChain<Block> + 'static,
 	C: ClientForGrandpa<Block, B> + 'static,
+	C::Api: GrandpaApi<Block, Error = sp_blockchain::Error>,
 	VR: VotingRule<Block, C> + Clone + 'static,
 {
 	type Output = Result<(), Error>;
@@ -175,6 +175,7 @@ where
 		select_chain: _,
 		persistent_data,
 		voter_commands_rx,
+		..
 	} = link;

 	let network = NetworkBridge::new(
@@ -40,7 +40,7 @@ use parity_scale_codec::Decode;
 use sp_runtime::traits::{Block as BlockT, Header as HeaderT, HashFor};
 use sp_runtime::generic::{BlockId, DigestItem};
 use sp_core::{H256, crypto::Public};
-use sp_finality_grandpa::{GRANDPA_ENGINE_ID, AuthorityList, GrandpaApi};
+use sp_finality_grandpa::{GRANDPA_ENGINE_ID, AuthorityList, EquivocationProof, GrandpaApi, OpaqueKeyOwnershipProof};
 use sp_state_machine::{InMemoryBackend, prove_read, read_proof_check};

 use authorities::AuthoritySet;
@@ -214,6 +214,20 @@ sp_api::mock_impl_runtime_apis! {
 		fn grandpa_authorities(&self) -> AuthorityList {
 			self.inner.genesis_authorities.clone()
 		}
+
+		fn submit_report_equivocation_extrinsic(
+			_equivocation_proof: EquivocationProof<Hash, BlockNumber>,
+			_key_owner_proof: OpaqueKeyOwnershipProof,
+		) -> Option<()> {
+			None
+		}
+
+		fn generate_key_ownership_proof(
+			_set_id: SetId,
+			_authority_id: AuthorityId,
+		) -> Option<OpaqueKeyOwnershipProof> {
+			None
+		}
 	}
 }

@@ -1664,7 +1678,7 @@ fn imports_justification_for_regular_blocks_on_import() {
 		};

 		let msg = finality_grandpa::Message::Precommit(precommit.clone());
-		let encoded = communication::localized_payload(round, set_id, &msg);
+		let encoded = sp_finality_grandpa::localized_payload(round, set_id, &msg);
 		let signature = peers[0].sign(&encoded[..]).into();

 		let precommit = finality_grandpa::SignedPrecommit {