BEEFY: gossip finality proofs (#13727)

* sc-consensus-beefy: add justifications to gossip protocol

* sc-consensus-beefy: voter gossips finality proofs

* sc-consensus-beefy: add finality proof gossip test

* sc-consensus-beefy: always gossip finality proof

Gossip finality proof in _both_ cases of reaching finality threshold
through votes:
1. threshold reached through self vote,
2. threshold reached through incoming vote.

* address comments

substrate/client/consensus/beefy/src/communication/gossip.rs

@@ -28,10 +28,17 @@ use log::{debug, trace};
 use parking_lot::{Mutex, RwLock};
 use wasm_timer::Instant;
 
-use crate::{communication::peers::KnownPeers, keystore::BeefyKeystore, LOG_TARGET};
+use crate::{
+	communication::peers::KnownPeers,
+	justification::{
+		proof_block_num_and_set_id, verify_with_validator_set, BeefyVersionedFinalityProof,
+	},
+	keystore::BeefyKeystore,
+	LOG_TARGET,
+};
 use sp_consensus_beefy::{
-	crypto::{Public, Signature},
-	ValidatorSetId, VoteMessage,
+	crypto::{AuthorityId, Signature},
+	ValidatorSet, ValidatorSetId, VoteMessage,
 };
 
 // Timeout for rebroadcasting messages.
@@ -40,59 +47,128 @@ const REBROADCAST_AFTER: Duration = Duration::from_secs(60);
 #[cfg(test)]
 const REBROADCAST_AFTER: Duration = Duration::from_secs(5);
 
-/// Gossip engine messages topic
-pub(crate) fn topic<B: Block>() -> B::Hash
+/// BEEFY gossip message type that gets encoded and sent on the network.
+#[derive(Debug, Encode, Decode)]
+pub(crate) enum GossipMessage<B: Block> {
+	/// BEEFY message with commitment and single signature.
+	Vote(VoteMessage<NumberFor<B>, AuthorityId, Signature>),
+	/// BEEFY justification with commitment and signatures.
+	FinalityProof(BeefyVersionedFinalityProof<B>),
+}
+
+impl<B: Block> GossipMessage<B> {
+	/// Return inner vote if this message is a Vote.
+	pub fn unwrap_vote(self) -> Option<VoteMessage<NumberFor<B>, AuthorityId, Signature>> {
+		match self {
+			GossipMessage::Vote(vote) => Some(vote),
+			GossipMessage::FinalityProof(_) => None,
+		}
+	}
+
+	/// Return inner finality proof if this message is a FinalityProof.
+	pub fn unwrap_finality_proof(self) -> Option<BeefyVersionedFinalityProof<B>> {
+		match self {
+			GossipMessage::Vote(_) => None,
+			GossipMessage::FinalityProof(proof) => Some(proof),
+		}
+	}
+}
+
+/// Gossip engine votes messages topic
+pub(crate) fn votes_topic<B: Block>() -> B::Hash
 where
 	B: Block,
 {
-	<<B::Header as Header>::Hashing as Hash>::hash(b"beefy")
+	<<B::Header as Header>::Hashing as Hash>::hash(b"beefy-votes")
 }
 
-#[derive(Debug)]
-pub(crate) struct GossipVoteFilter<B: Block> {
-	pub start: NumberFor<B>,
-	pub end: NumberFor<B>,
-	pub validator_set_id: ValidatorSetId,
+/// Gossip engine justifications messages topic
+pub(crate) fn proofs_topic<B: Block>() -> B::Hash
+where
+	B: Block,
+{
+	<<B::Header as Header>::Hashing as Hash>::hash(b"beefy-justifications")
 }
 
 /// A type that represents hash of the message.
 pub type MessageHash = [u8; 8];
 
-struct VotesFilter<B: Block> {
-	filter: Option<GossipVoteFilter<B>>,
-	live: BTreeMap<NumberFor<B>, fnv::FnvHashSet<MessageHash>>,
+#[derive(Clone, Debug)]
+pub(crate) struct GossipFilterCfg<'a, B: Block> {
+	pub start: NumberFor<B>,
+	pub end: NumberFor<B>,
+	pub validator_set: &'a ValidatorSet<AuthorityId>,
 }
 
-impl<B: Block> VotesFilter<B> {
+#[derive(Clone, Debug)]
+struct FilterInner<B: Block> {
+	pub start: NumberFor<B>,
+	pub end: NumberFor<B>,
+	pub validator_set: ValidatorSet<AuthorityId>,
+}
+
+struct Filter<B: Block> {
+	inner: Option<FilterInner<B>>,
+	live_votes: BTreeMap<NumberFor<B>, fnv::FnvHashSet<MessageHash>>,
+}
+
+impl<B: Block> Filter<B> {
 	pub fn new() -> Self {
-		Self { filter: None, live: BTreeMap::new() }
+		Self { inner: None, live_votes: BTreeMap::new() }
 	}
 
 	/// Update filter to new `start` and `set_id`.
-	fn update(&mut self, filter: GossipVoteFilter<B>) {
-		self.live.retain(|&round, _| round >= filter.start && round <= filter.end);
-		self.filter = Some(filter);
+	fn update(&mut self, cfg: GossipFilterCfg<B>) {
+		self.live_votes.retain(|&round, _| round >= cfg.start && round <= cfg.end);
+		// only clone+overwrite big validator_set if set_id changed
+		match self.inner.as_mut() {
+			Some(f) if f.validator_set.id() == cfg.validator_set.id() => {
+				f.start = cfg.start;
+				f.end = cfg.end;
+			},
+			_ =>
+				self.inner = Some(FilterInner {
+					start: cfg.start,
+					end: cfg.end,
+					validator_set: cfg.validator_set.clone(),
+				}),
+		}
+	}
+
+	/// Return true if `max(session_start, best_beefy) <= round <= best_grandpa`,
+	/// and vote `set_id` matches session set id.
+	///
+	/// Latest concluded round is still considered alive to allow proper gossiping for it.
+	fn is_vote_accepted(&self, round: NumberFor<B>, set_id: ValidatorSetId) -> bool {
+		self.inner
+			.as_ref()
+			.map(|f| set_id == f.validator_set.id() && round >= f.start && round <= f.end)
+			.unwrap_or(false)
 	}
 
 	/// Return true if `round` is >= than `max(session_start, best_beefy)`,
-	/// and vote set id matches session set id.
+	/// and proof `set_id` matches session set id.
 	///
 	/// Latest concluded round is still considered alive to allow proper gossiping for it.
-	fn is_live(&self, round: NumberFor<B>, set_id: ValidatorSetId) -> bool {
-		self.filter
+	fn is_finality_proof_accepted(&self, round: NumberFor<B>, set_id: ValidatorSetId) -> bool {
+		self.inner
 			.as_ref()
-			.map(|f| set_id == f.validator_set_id && round >= f.start && round <= f.end)
+			.map(|f| set_id == f.validator_set.id() && round >= f.start)
 			.unwrap_or(false)
 	}
 
 	/// Add new _known_ `hash` to the round's known votes.
-	fn add_known(&mut self, round: NumberFor<B>, hash: MessageHash) {
-		self.live.entry(round).or_default().insert(hash);
+	fn add_known_vote(&mut self, round: NumberFor<B>, hash: MessageHash) {
+		self.live_votes.entry(round).or_default().insert(hash);
 	}
 
 	/// Check if `hash` is already part of round's known votes.
-	fn is_known(&self, round: NumberFor<B>, hash: &MessageHash) -> bool {
-		self.live.get(&round).map(|known| known.contains(hash)).unwrap_or(false)
+	fn is_known_vote(&self, round: NumberFor<B>, hash: &MessageHash) -> bool {
+		self.live_votes.get(&round).map(|known| known.contains(hash)).unwrap_or(false)
+	}
+
+	fn validator_set(&self) -> Option<&ValidatorSet<AuthorityId>> {
+		self.inner.as_ref().map(|f| &f.validator_set)
 	}
 }
 
@@ -108,8 +184,9 @@ pub(crate) struct GossipValidator<B>
 where
 	B: Block,
 {
-	topic: B::Hash,
-	votes_filter: RwLock<VotesFilter<B>>,
+	votes_topic: B::Hash,
+	justifs_topic: B::Hash,
+	gossip_filter: RwLock<Filter<B>>,
 	next_rebroadcast: Mutex<Instant>,
 	known_peers: Arc<Mutex<KnownPeers<B>>>,
 }
@@ -120,8 +197,9 @@ where
 {
 	pub fn new(known_peers: Arc<Mutex<KnownPeers<B>>>) -> GossipValidator<B> {
 		GossipValidator {
-			topic: topic::<B>(),
-			votes_filter: RwLock::new(VotesFilter::new()),
+			votes_topic: votes_topic::<B>(),
+			justifs_topic: proofs_topic::<B>(),
+			gossip_filter: RwLock::new(Filter::new()),
 			next_rebroadcast: Mutex::new(Instant::now() + REBROADCAST_AFTER),
 			known_peers,
 		}
@@ -130,9 +208,79 @@ where
 	/// Update gossip validator filter.
 	///
 	/// Only votes for `set_id` and rounds `start <= round <= end` will be accepted.
-	pub(crate) fn update_filter(&self, filter: GossipVoteFilter<B>) {
+	pub(crate) fn update_filter(&self, filter: GossipFilterCfg<B>) {
 		debug!(target: LOG_TARGET, "🥩 New gossip filter {:?}", filter);
-		self.votes_filter.write().update(filter);
+		self.gossip_filter.write().update(filter);
+	}
+
+	fn validate_vote(
+		&self,
+		vote: VoteMessage<NumberFor<B>, AuthorityId, Signature>,
+		sender: &PeerId,
+		data: &[u8],
+	) -> ValidationResult<B::Hash> {
+		let msg_hash = twox_64(data);
+		let round = vote.commitment.block_number;
+		let set_id = vote.commitment.validator_set_id;
+		self.known_peers.lock().note_vote_for(*sender, round);
+
+		// Verify general usefulness of the message.
+		// We are going to discard old votes right away (without verification)
+		// Also we keep track of already received votes to avoid verifying duplicates.
+		{
+			let filter = self.gossip_filter.read();
+
+			if !filter.is_vote_accepted(round, set_id) {
+				return ValidationResult::Discard
+			}
+
+			if filter.is_known_vote(round, &msg_hash) {
+				return ValidationResult::ProcessAndKeep(self.votes_topic)
+			}
+		}
+
+		if BeefyKeystore::verify(&vote.id, &vote.signature, &vote.commitment.encode()) {
+			self.gossip_filter.write().add_known_vote(round, msg_hash);
+			ValidationResult::ProcessAndKeep(self.votes_topic)
+		} else {
+			// TODO: report peer
+			debug!(
+				target: LOG_TARGET,
+				"🥩 Bad signature on message: {:?}, from: {:?}", vote, sender
+			);
+			ValidationResult::Discard
+		}
+	}
+
+	fn validate_finality_proof(
+		&self,
+		proof: BeefyVersionedFinalityProof<B>,
+		sender: &PeerId,
+	) -> ValidationResult<B::Hash> {
+		let (round, set_id) = proof_block_num_and_set_id::<B>(&proof);
+		self.known_peers.lock().note_vote_for(*sender, round);
+
+		let guard = self.gossip_filter.read();
+		// Verify general usefulness of the justifications.
+		if !guard.is_finality_proof_accepted(round, set_id) {
+			return ValidationResult::Discard
+		}
+		// Verify justification signatures.
+		guard
+			.validator_set()
+			.map(|validator_set| {
+				if let Ok(()) = verify_with_validator_set::<B>(round, validator_set, &proof) {
+					ValidationResult::ProcessAndKeep(self.justifs_topic)
+				} else {
+					// TODO: report peer
+					debug!(
+						target: LOG_TARGET,
+						"🥩 Bad signatures on message: {:?}, from: {:?}", proof, sender
+					);
+					ValidationResult::Discard
+				}
+			})
+			.unwrap_or(ValidationResult::Discard)
 	}
 }
 
@@ -150,57 +298,38 @@ where
 		sender: &PeerId,
 		mut data: &[u8],
 	) -> ValidationResult<B::Hash> {
-		if let Ok(msg) = VoteMessage::<NumberFor<B>, Public, Signature>::decode(&mut data) {
-			let msg_hash = twox_64(data);
-			let round = msg.commitment.block_number;
-			let set_id = msg.commitment.validator_set_id;
-			self.known_peers.lock().note_vote_for(*sender, round);
-
-			// Verify general usefulness of the message.
-			// We are going to discard old votes right away (without verification)
-			// Also we keep track of already received votes to avoid verifying duplicates.
-			{
-				let filter = self.votes_filter.read();
-
-				if !filter.is_live(round, set_id) {
-					return ValidationResult::Discard
-				}
-
-				if filter.is_known(round, &msg_hash) {
-					return ValidationResult::ProcessAndKeep(self.topic)
-				}
-			}
-
-			if BeefyKeystore::verify(&msg.id, &msg.signature, &msg.commitment.encode()) {
-				self.votes_filter.write().add_known(round, msg_hash);
-				return ValidationResult::ProcessAndKeep(self.topic)
-			} else {
-				// TODO: report peer
-				debug!(
-					target: LOG_TARGET,
-					"🥩 Bad signature on message: {:?}, from: {:?}", msg, sender
-				);
-			}
+		match GossipMessage::<B>::decode(&mut data) {
+			Ok(GossipMessage::Vote(msg)) => self.validate_vote(msg, sender, data),
+			Ok(GossipMessage::FinalityProof(proof)) => self.validate_finality_proof(proof, sender),
+			Err(e) => {
+				debug!(target: LOG_TARGET, "Error decoding message: {}", e);
+				ValidationResult::Discard
+			},
 		}
-
-		ValidationResult::Discard
 	}
 
 	fn message_expired<'a>(&'a self) -> Box<dyn FnMut(B::Hash, &[u8]) -> bool + 'a> {
-		let filter = self.votes_filter.read();
-		Box::new(move |_topic, mut data| {
-			let msg = match VoteMessage::<NumberFor<B>, Public, Signature>::decode(&mut data) {
-				Ok(vote) => vote,
-				Err(_) => return true,
-			};
-
-			let round = msg.commitment.block_number;
-			let set_id = msg.commitment.validator_set_id;
-			let expired = !filter.is_live(round, set_id);
-
-			trace!(target: LOG_TARGET, "🥩 Message for round #{} expired: {}", round, expired);
-
-			expired
+		let filter = self.gossip_filter.read();
+		Box::new(move |_topic, mut data| match GossipMessage::<B>::decode(&mut data) {
+			Ok(GossipMessage::Vote(msg)) => {
+				let round = msg.commitment.block_number;
+				let set_id = msg.commitment.validator_set_id;
+				let expired = !filter.is_vote_accepted(round, set_id);
+				trace!(target: LOG_TARGET, "🥩 Vote for round #{} expired: {}", round, expired);
+				expired
+			},
+			Ok(GossipMessage::FinalityProof(proof)) => {
+				let (round, set_id) = proof_block_num_and_set_id::<B>(&proof);
+				let expired = !filter.is_finality_proof_accepted(round, set_id);
+				trace!(
+					target: LOG_TARGET,
+					"🥩 Finality proof for round #{} expired: {}",
+					round,
+					expired
+				);
+				expired
+			},
+			Err(_) => true,
 		})
 	}
 
@@ -219,68 +348,80 @@ where
 			}
 		};
 
-		let filter = self.votes_filter.read();
+		let filter = self.gossip_filter.read();
 		Box::new(move |_who, intent, _topic, mut data| {
 			if let MessageIntent::PeriodicRebroadcast = intent {
 				return do_rebroadcast
 			}
 
-			let msg = match VoteMessage::<NumberFor<B>, Public, Signature>::decode(&mut data) {
-				Ok(vote) => vote,
-				Err(_) => return false,
-			};
-
-			let round = msg.commitment.block_number;
-			let set_id = msg.commitment.validator_set_id;
-			let allowed = filter.is_live(round, set_id);
-
-			trace!(target: LOG_TARGET, "🥩 Message for round #{} allowed: {}", round, allowed);
-
-			allowed
+			match GossipMessage::<B>::decode(&mut data) {
+				Ok(GossipMessage::Vote(msg)) => {
+					let round = msg.commitment.block_number;
+					let set_id = msg.commitment.validator_set_id;
+					let allowed = filter.is_vote_accepted(round, set_id);
+					trace!(target: LOG_TARGET, "🥩 Vote for round #{} allowed: {}", round, allowed);
+					allowed
+				},
+				Ok(GossipMessage::FinalityProof(proof)) => {
+					let (round, set_id) = proof_block_num_and_set_id::<B>(&proof);
+					let allowed = filter.is_finality_proof_accepted(round, set_id);
+					trace!(
+						target: LOG_TARGET,
+						"🥩 Finality proof for round #{} allowed: {}",
+						round,
+						allowed
+					);
+					allowed
+				},
+				Err(_) => false,
+			}
 		})
 	}
 }
 
 #[cfg(test)]
-mod tests {
+pub(crate) mod tests {
 	use super::*;
 	use crate::keystore::BeefyKeystore;
 	use sc_network_test::Block;
 	use sp_consensus_beefy::{
-		crypto::Signature, known_payloads, Commitment, Keyring, MmrRootHash, Payload, VoteMessage,
-		KEY_TYPE,
+		crypto::Signature, known_payloads, Commitment, Keyring, MmrRootHash, Payload,
+		SignedCommitment, VoteMessage, KEY_TYPE,
 	};
 	use sp_keystore::{testing::MemoryKeystore, Keystore};
 
 	#[test]
 	fn known_votes_insert_remove() {
-		let mut kv = VotesFilter::<Block>::new();
+		let mut filter = Filter::<Block>::new();
 		let msg_hash = twox_64(b"data");
+		let keys = vec![Keyring::Alice.public()];
+		let validator_set = ValidatorSet::<AuthorityId>::new(keys.clone(), 1).unwrap();
 
-		kv.add_known(1, msg_hash);
-		kv.add_known(1, msg_hash);
-		kv.add_known(2, msg_hash);
-		assert_eq!(kv.live.len(), 2);
+		filter.add_known_vote(1, msg_hash);
+		filter.add_known_vote(1, msg_hash);
+		filter.add_known_vote(2, msg_hash);
+		assert_eq!(filter.live_votes.len(), 2);
 
-		kv.add_known(3, msg_hash);
-		assert!(kv.is_known(3, &msg_hash));
-		assert!(!kv.is_known(3, &twox_64(b"other")));
-		assert!(!kv.is_known(4, &msg_hash));
-		assert_eq!(kv.live.len(), 3);
+		filter.add_known_vote(3, msg_hash);
+		assert!(filter.is_known_vote(3, &msg_hash));
+		assert!(!filter.is_known_vote(3, &twox_64(b"other")));
+		assert!(!filter.is_known_vote(4, &msg_hash));
+		assert_eq!(filter.live_votes.len(), 3);
 
-		assert!(kv.filter.is_none());
-		assert!(!kv.is_live(1, 1));
+		assert!(filter.inner.is_none());
+		assert!(!filter.is_vote_accepted(1, 1));
 
-		kv.update(GossipVoteFilter { start: 3, end: 10, validator_set_id: 1 });
-		assert_eq!(kv.live.len(), 1);
-		assert!(kv.live.contains_key(&3));
-		assert!(!kv.is_live(2, 1));
-		assert!(kv.is_live(3, 1));
-		assert!(kv.is_live(4, 1));
-		assert!(!kv.is_live(4, 2));
+		filter.update(GossipFilterCfg { start: 3, end: 10, validator_set: &validator_set });
+		assert_eq!(filter.live_votes.len(), 1);
+		assert!(filter.live_votes.contains_key(&3));
+		assert!(!filter.is_vote_accepted(2, 1));
+		assert!(filter.is_vote_accepted(3, 1));
+		assert!(filter.is_vote_accepted(4, 1));
+		assert!(!filter.is_vote_accepted(4, 2));
 
-		kv.update(GossipVoteFilter { start: 5, end: 10, validator_set_id: 2 });
-		assert!(kv.live.is_empty());
+		let validator_set = ValidatorSet::<AuthorityId>::new(keys, 2).unwrap();
+		filter.update(GossipFilterCfg { start: 5, end: 10, validator_set: &validator_set });
+		assert!(filter.live_votes.is_empty());
 	}
 
 	struct TestContext;
@@ -302,14 +443,14 @@ mod tests {
 		}
 	}
 
-	fn sign_commitment<BN: Encode>(who: &Keyring, commitment: &Commitment<BN>) -> Signature {
+	pub fn sign_commitment<BN: Encode>(who: &Keyring, commitment: &Commitment<BN>) -> Signature {
 		let store = MemoryKeystore::new();
 		store.ecdsa_generate_new(KEY_TYPE, Some(&who.to_seed())).unwrap();
 		let beefy_keystore: BeefyKeystore = Some(store.into()).into();
 		beefy_keystore.sign(&who.public(), &commitment.encode()).unwrap()
 	}
 
-	fn dummy_vote(block_number: u64) -> VoteMessage<u64, Public, Signature> {
+	fn dummy_vote(block_number: u64) -> VoteMessage<u64, AuthorityId, Signature> {
 		let payload = Payload::from_single_entry(
 			known_payloads::MMR_ROOT_ID,
 			MmrRootHash::default().encode(),
@@ -320,51 +461,111 @@ mod tests {
 		VoteMessage { commitment, id: Keyring::Alice.public(), signature }
 	}
 
+	pub fn dummy_proof(
+		block_number: u64,
+		validator_set: &ValidatorSet<AuthorityId>,
+	) -> BeefyVersionedFinalityProof<Block> {
+		let payload = Payload::from_single_entry(
+			known_payloads::MMR_ROOT_ID,
+			MmrRootHash::default().encode(),
+		);
+		let commitment = Commitment { payload, block_number, validator_set_id: validator_set.id() };
+		let signatures = validator_set
+			.validators()
+			.iter()
+			.map(|validator: &AuthorityId| {
+				Some(sign_commitment(&Keyring::from_public(validator).unwrap(), &commitment))
+			})
+			.collect();
+
+		BeefyVersionedFinalityProof::<Block>::V1(SignedCommitment { commitment, signatures })
+	}
+
 	#[test]
-	fn should_avoid_verifying_signatures_twice() {
+	fn should_validate_messages() {
+		let keys = vec![Keyring::Alice.public()];
+		let validator_set = ValidatorSet::<AuthorityId>::new(keys.clone(), 0).unwrap();
 		let gv = GossipValidator::<Block>::new(Arc::new(Mutex::new(KnownPeers::new())));
-		gv.update_filter(GossipVoteFilter { start: 0, end: 10, validator_set_id: 0 });
+		gv.update_filter(GossipFilterCfg { start: 0, end: 10, validator_set: &validator_set });
 		let sender = sc_network::PeerId::random();
 		let mut context = TestContext;
 
 		let vote = dummy_vote(3);
+		let gossip_vote = GossipMessage::<Block>::Vote(vote.clone());
 
 		// first time the cache should be populated
-		let res = gv.validate(&mut context, &sender, &vote.encode());
+		let res = gv.validate(&mut context, &sender, &gossip_vote.encode());
 
 		assert!(matches!(res, ValidationResult::ProcessAndKeep(_)));
 		assert_eq!(
-			gv.votes_filter.read().live.get(&vote.commitment.block_number).map(|x| x.len()),
+			gv.gossip_filter
+				.read()
+				.live_votes
+				.get(&vote.commitment.block_number)
+				.map(|x| x.len()),
 			Some(1)
 		);
 
 		// second time we should hit the cache
-		let res = gv.validate(&mut context, &sender, &vote.encode());
-
+		let res = gv.validate(&mut context, &sender, &gossip_vote.encode());
 		assert!(matches!(res, ValidationResult::ProcessAndKeep(_)));
 
 		// next we should quickly reject if the round is not live
-		gv.update_filter(GossipVoteFilter { start: 7, end: 10, validator_set_id: 0 });
+		gv.update_filter(GossipFilterCfg { start: 7, end: 10, validator_set: &validator_set });
 
 		let number = vote.commitment.block_number;
 		let set_id = vote.commitment.validator_set_id;
-		assert!(!gv.votes_filter.read().is_live(number, set_id));
+		assert!(!gv.gossip_filter.read().is_vote_accepted(number, set_id));
 
 		let res = gv.validate(&mut context, &sender, &vote.encode());
+		assert!(matches!(res, ValidationResult::Discard));
 
+		// reject old proof
+		let proof = dummy_proof(5, &validator_set);
+		let encoded_proof = GossipMessage::<Block>::FinalityProof(proof).encode();
+		let res = gv.validate(&mut context, &sender, &encoded_proof);
+		assert!(matches!(res, ValidationResult::Discard));
+
+		// accept next proof with good set_id
+		let proof = dummy_proof(7, &validator_set);
+		let encoded_proof = GossipMessage::<Block>::FinalityProof(proof).encode();
+		let res = gv.validate(&mut context, &sender, &encoded_proof);
+		assert!(matches!(res, ValidationResult::ProcessAndKeep(_)));
+
+		// accept future proof with good set_id
+		let proof = dummy_proof(20, &validator_set);
+		let encoded_proof = GossipMessage::<Block>::FinalityProof(proof).encode();
+		let res = gv.validate(&mut context, &sender, &encoded_proof);
+		assert!(matches!(res, ValidationResult::ProcessAndKeep(_)));
+
+		// reject proof, wrong set_id
+		let bad_validator_set = ValidatorSet::<AuthorityId>::new(keys, 1).unwrap();
+		let proof = dummy_proof(20, &bad_validator_set);
+		let encoded_proof = GossipMessage::<Block>::FinalityProof(proof).encode();
+		let res = gv.validate(&mut context, &sender, &encoded_proof);
+		assert!(matches!(res, ValidationResult::Discard));
+
+		// reject proof, bad signatures (Bob instead of Alice)
+		let bad_validator_set =
+			ValidatorSet::<AuthorityId>::new(vec![Keyring::Bob.public()], 0).unwrap();
+		let proof = dummy_proof(20, &bad_validator_set);
+		let encoded_proof = GossipMessage::<Block>::FinalityProof(proof).encode();
+		let res = gv.validate(&mut context, &sender, &encoded_proof);
 		assert!(matches!(res, ValidationResult::Discard));
 	}
 
 	#[test]
 	fn messages_allowed_and_expired() {
+		let keys = vec![Keyring::Alice.public()];
+		let validator_set = ValidatorSet::<AuthorityId>::new(keys.clone(), 0).unwrap();
 		let gv = GossipValidator::<Block>::new(Arc::new(Mutex::new(KnownPeers::new())));
-		gv.update_filter(GossipVoteFilter { start: 0, end: 10, validator_set_id: 0 });
+		gv.update_filter(GossipFilterCfg { start: 0, end: 10, validator_set: &validator_set });
 		let sender = sc_network::PeerId::random();
 		let topic = Default::default();
 		let intent = MessageIntent::Broadcast;
 
 		// conclude 2
-		gv.update_filter(GossipVoteFilter { start: 2, end: 10, validator_set_id: 0 });
+		gv.update_filter(GossipFilterCfg { start: 2, end: 10, validator_set: &validator_set });
 		let mut allowed = gv.message_allowed();
 		let mut expired = gv.message_expired();
 
@@ -374,33 +575,68 @@ mod tests {
 
 		// inactive round 1 -> expired
 		let vote = dummy_vote(1);
-		let mut encoded_vote = vote.encode();
+		let mut encoded_vote = GossipMessage::<Block>::Vote(vote).encode();
 		assert!(!allowed(&sender, intent, &topic, &mut encoded_vote));
 		assert!(expired(topic, &mut encoded_vote));
+		let proof = dummy_proof(1, &validator_set);
+		let mut encoded_proof = GossipMessage::<Block>::FinalityProof(proof).encode();
+		assert!(!allowed(&sender, intent, &topic, &mut encoded_proof));
+		assert!(expired(topic, &mut encoded_proof));
 
 		// active round 2 -> !expired - concluded but still gossiped
 		let vote = dummy_vote(2);
-		let mut encoded_vote = vote.encode();
+		let mut encoded_vote = GossipMessage::<Block>::Vote(vote).encode();
 		assert!(allowed(&sender, intent, &topic, &mut encoded_vote));
 		assert!(!expired(topic, &mut encoded_vote));
+		let proof = dummy_proof(2, &validator_set);
+		let mut encoded_proof = GossipMessage::<Block>::FinalityProof(proof).encode();
+		assert!(allowed(&sender, intent, &topic, &mut encoded_proof));
+		assert!(!expired(topic, &mut encoded_proof));
+		// using wrong set_id -> !allowed, expired
+		let bad_validator_set = ValidatorSet::<AuthorityId>::new(keys.clone(), 1).unwrap();
+		let proof = dummy_proof(2, &bad_validator_set);
+		let mut encoded_proof = GossipMessage::<Block>::FinalityProof(proof).encode();
+		assert!(!allowed(&sender, intent, &topic, &mut encoded_proof));
+		assert!(expired(topic, &mut encoded_proof));
 
 		// in progress round 3 -> !expired
 		let vote = dummy_vote(3);
-		let mut encoded_vote = vote.encode();
+		let mut encoded_vote = GossipMessage::<Block>::Vote(vote).encode();
 		assert!(allowed(&sender, intent, &topic, &mut encoded_vote));
 		assert!(!expired(topic, &mut encoded_vote));
+		let proof = dummy_proof(3, &validator_set);
+		let mut encoded_proof = GossipMessage::<Block>::FinalityProof(proof).encode();
+		assert!(allowed(&sender, intent, &topic, &mut encoded_proof));
+		assert!(!expired(topic, &mut encoded_proof));
 
 		// unseen round 4 -> !expired
-		let vote = dummy_vote(3);
-		let mut encoded_vote = vote.encode();
+		let vote = dummy_vote(4);
+		let mut encoded_vote = GossipMessage::<Block>::Vote(vote).encode();
 		assert!(allowed(&sender, intent, &topic, &mut encoded_vote));
 		assert!(!expired(topic, &mut encoded_vote));
+		let proof = dummy_proof(4, &validator_set);
+		let mut encoded_proof = GossipMessage::<Block>::FinalityProof(proof).encode();
+		assert!(allowed(&sender, intent, &topic, &mut encoded_proof));
+		assert!(!expired(topic, &mut encoded_proof));
+
+		// future round 11 -> expired
+		let vote = dummy_vote(11);
+		let mut encoded_vote = GossipMessage::<Block>::Vote(vote).encode();
+		assert!(!allowed(&sender, intent, &topic, &mut encoded_vote));
+		assert!(expired(topic, &mut encoded_vote));
+		// future proofs allowed while same set_id -> allowed
+		let proof = dummy_proof(11, &validator_set);
+		let mut encoded_proof = GossipMessage::<Block>::FinalityProof(proof).encode();
+		assert!(allowed(&sender, intent, &topic, &mut encoded_proof));
+		assert!(!expired(topic, &mut encoded_proof));
 	}
 
 	#[test]
 	fn messages_rebroadcast() {
+		let keys = vec![Keyring::Alice.public()];
+		let validator_set = ValidatorSet::<AuthorityId>::new(keys.clone(), 0).unwrap();
 		let gv = GossipValidator::<Block>::new(Arc::new(Mutex::new(KnownPeers::new())));
-		gv.update_filter(GossipVoteFilter { start: 0, end: 10, validator_set_id: 0 });
+		gv.update_filter(GossipFilterCfg { start: 0, end: 10, validator_set: &validator_set });
 		let sender = sc_network::PeerId::random();
 		let topic = Default::default();
 

substrate/client/consensus/beefy/src/communication/mod.rs

@@ -29,7 +29,7 @@ pub(crate) mod beefy_protocol_name {
 	use sc_network::ProtocolName;
 
 	/// BEEFY votes gossip protocol name suffix.
-	const GOSSIP_NAME: &str = "/beefy/1";
+	const GOSSIP_NAME: &str = "/beefy/2";
 	/// BEEFY justifications protocol name suffix.
 	const JUSTIFICATIONS_NAME: &str = "/beefy/justifications/1";
 
@@ -86,7 +86,7 @@ mod tests {
 		let genesis_hash = H256::random();
 		let genesis_hex = array_bytes::bytes2hex("", genesis_hash.as_ref());
 
-		let expected_gossip_name = format!("/{}/beefy/1", genesis_hex);
+		let expected_gossip_name = format!("/{}/beefy/2", genesis_hex);
 		let gossip_proto_name = gossip_protocol_name(&genesis_hash, None);
 		assert_eq!(gossip_proto_name.to_string(), expected_gossip_name);
 
@@ -101,7 +101,7 @@ mod tests {
 		];
 		let genesis_hex = "32043c7b3a6ad8f6c2bc8bc121d4caab09377b5e082b0cfbbb39ad13bc4acd93";
 
-		let expected_gossip_name = format!("/{}/beefy/1", genesis_hex);
+		let expected_gossip_name = format!("/{}/beefy/2", genesis_hex);
 		let gossip_proto_name = gossip_protocol_name(&genesis_hash, None);
 		assert_eq!(gossip_proto_name.to_string(), expected_gossip_name);