grandpa: save historical votes

core/finality-grandpa/src/communication/gossip.rs

@@ -763,7 +763,7 @@ impl<Block: BlockT> Inner<Block> {
 		// code below assumes this invariant is maintained when creating the
 		// catch up reply since peers won't accept catch-up messages that have
 		// too many equivocations (we exceed the fault-tolerance bound).
-		for vote in last_completed_round.votes {
+		for vote in last_completed_round.historical_votes.seen().clone() {
 			match vote.message {
 				grandpa::Message::Prevote(prevote) => {
 					prevotes.push(grandpa::SignedPrevote {
@@ -1231,6 +1231,7 @@ impl<B: BlockT, N: super::Network<B>> Future for ReportingTask<B, N> {
 mod tests {
 	use super::*;
 	use super::environment::SharedVoterSetState;
+	use crate::HistoricalVotes;
 	use network_gossip::Validator as GossipValidatorT;
 	use network::test::Block;
 
@@ -1246,24 +1247,27 @@ mod tests {
 
 	// dummy voter set state
 	fn voter_set_state() -> SharedVoterSetState<Block> {
-		use crate::authorities::AuthoritySet;
 		use crate::environment::{CompletedRound, CompletedRounds, HasVoted, VoterSetState};
 		use grandpa::round::State as RoundState;
 		use substrate_primitives::H256;
 
 		let state = RoundState::genesis((H256::zero(), 0));
 		let base = state.prevote_ghost.unwrap();
-		let voters = AuthoritySet::genesis(Vec::new());
+		let voters = Vec::new();
+		let completed_round = CompletedRound {
+			state,
+			number: 0,
+			base,
+			historical_votes: HistoricalVotes::<Block>::new(),
+		};
+		let mut rounds = VecDeque::new();
+		rounds.push_back(completed_round);
+
 		let set_state = VoterSetState::Live {
 			completed_rounds: CompletedRounds::new(
-				CompletedRound {
-					state,
-					number: 0,
-					votes: Vec::new(),
-					base,
-				},
+				rounds,
 				0,
-				&voters,
+				voters,
 			),
 			current_round: HasVoted::No,
 		};
@@ -1545,7 +1549,7 @@ mod tests {
 				number: 1,
 				state: grandpa::round::State::genesis(Default::default()),
 				base: Default::default(),
-				votes: Default::default(),
+				historical_votes: HistoricalVotes::<Block>::new(),
 			}));
 
 			let set_state = environment::VoterSetState::<Block>::Live {

core/finality-grandpa/src/communication/mod.rs

@@ -265,7 +265,7 @@ impl<B: BlockT, N: Network<B>> NetworkBridge<B, N> {
 				// messages will be ignored.
 				validator.note_round(Round(round.number), |_, _| {});
 
-				for signed in round.votes.iter() {
+				for signed in round.historical_votes.seen().iter() {
 					let message = gossip::GossipMessage::VoteOrPrecommit(
 						gossip::VoteOrPrecommitMessage::<B> {
 							message: signed.clone(),
@@ -282,7 +282,7 @@ impl<B: BlockT, N: Network<B>> NetworkBridge<B, N> {
 
 				trace!(target: "afg",
 					"Registered {} messages for topic {:?} (round: {}, set_id: {})",
-					round.votes.len(),
+					round.historical_votes.seen().len(),
 					topic,
 					round.number,
 					set_id,

core/finality-grandpa/src/communication/tests.rs

@@ -23,10 +23,12 @@ use network::test::{Block, Hash};
 use network_gossip::Validator;
 use tokio::runtime::current_thread;
 use std::sync::Arc;
+use std::collections::VecDeque;
 use keyring::AuthorityKeyring;
 use parity_codec::Encode;
 
 use crate::environment::SharedVoterSetState;
+use crate::HistoricalVotes;
 use super::gossip::{self, GossipValidator};
 use super::{AuthorityId, VoterSet, Round, SetId};
 
@@ -140,24 +142,26 @@ fn config() -> crate::Config {
 
 // dummy voter set state
 fn voter_set_state() -> SharedVoterSetState<Block> {
-	use crate::authorities::AuthoritySet;
 	use crate::environment::{CompletedRound, CompletedRounds, HasVoted, VoterSetState};
 	use grandpa::round::State as RoundState;
 	use substrate_primitives::H256;
 
 	let state = RoundState::genesis((H256::zero(), 0));
 	let base = state.prevote_ghost.unwrap();
-	let voters = AuthoritySet::genesis(Vec::new());
+	let voters = Vec::new();
+	let completed_round = CompletedRound {
+		state,
+		number: 0,
+		base,
+		historical_votes: HistoricalVotes::<Block>::new(),
+	};
+	let mut rounds = VecDeque::new();
+	rounds.push_back(completed_round);
 	let set_state = VoterSetState::Live {
 		completed_rounds: CompletedRounds::new(
-			CompletedRound {
-				state,
-				number: 0,
-				votes: Vec::new(),
-				base,
-			},
+			rounds,
 			0,
-			&voters,
+			voters,
 		),
 		current_round: HasVoted::No,
 	};

core/finality-grandpa/src/environment.rs

@@ -41,12 +41,12 @@ use substrate_telemetry::{telemetry, CONSENSUS_INFO};
 
 use crate::{
 	CommandOrError, Commit, Config, Error, Network, Precommit, Prevote,
-	PrimaryPropose, SignedMessage, NewAuthoritySet, VoterCommand,
+	PrimaryPropose, NewAuthoritySet, VoterCommand,
 };
 
 use consensus_common::SelectChain;
 
-use crate::authorities::{AuthoritySet, SharedAuthoritySet};
+use crate::authorities::SharedAuthoritySet;
 use crate::consensus_changes::SharedConsensusChanges;
 use crate::justification::GrandpaJustification;
 use crate::until_imported::UntilVoteTargetImported;
@@ -70,7 +70,7 @@ pub struct CompletedRound<Block: BlockT> {
 	/// The target block base used for voting in the round.
 	pub base: (Block::Hash, NumberFor<Block>),
 	/// All the votes observed in the round.
-	pub votes: Vec<SignedMessage<Block>>,
+	pub historical_votes: HistoricalVotes<Block>,
 }
 
 // Data about last completed rounds within a single voter set. Stores NUM_LAST_COMPLETED_ROUNDS and always
@@ -82,6 +82,7 @@ pub struct CompletedRounds<Block: BlockT> {
 	voters: Vec<AuthorityId>,
 }
 
+
 // NOTE: the current strategy for persisting completed rounds is very naive
 // (update everything) and we also rely on cloning to do atomic updates,
 // therefore this value should be kept small for now.
@@ -108,16 +109,12 @@ impl<Block: BlockT> Decode for CompletedRounds<Block> {
 impl<Block: BlockT> CompletedRounds<Block> {
 	/// Create a new completed rounds tracker with NUM_LAST_COMPLETED_ROUNDS capacity.
 	pub(crate) fn new(
-		genesis: CompletedRound<Block>,
+		rounds: VecDeque<CompletedRound<Block>>,
 		set_id: u64,
-		voters: &AuthoritySet<Block::Hash, NumberFor<Block>>,
+		voters: Vec<AuthorityId>,
 	)
 		-> CompletedRounds<Block>
 	{
-		let mut rounds = VecDeque::with_capacity(NUM_LAST_COMPLETED_ROUNDS);
-		rounds.push_back(genesis);
-
-		let voters = voters.current().1.iter().map(|(a, _)| a.clone()).collect();
 		CompletedRounds { rounds, set_id, voters }
 	}
 
@@ -668,15 +665,12 @@ where
 		self.update_voter_set_state(|voter_set_state| {
 			let mut completed_rounds = voter_set_state.completed_rounds();
 
-			// TODO: Future integration will store the prevote and precommit index. See #2611.
-			let votes = historical_votes.seen().clone();
-
 			// NOTE: the Environment assumes that rounds are *always* completed in-order.
 			if !completed_rounds.push(CompletedRound {
 				number: round,
 				state: state.clone(),
 				base,
-				votes,
+				historical_votes: historical_votes.clone(),
 			}) {
 				let msg = "Voter completed round that is older than the last completed round.";
 				return Err(Error::Safety(msg.to_string()));

core/finality-grandpa/src/lib.rs

@@ -77,6 +77,7 @@ use grandpa::{voter, round::State as RoundState, BlockNumberOps, voter_set::Vote
 use std::fmt;
 use std::sync::Arc;
 use std::time::Duration;
+use std::collections::VecDeque;
 
 mod authorities;
 mod aux_schema;
@@ -115,6 +116,7 @@ mod tests;
 
 /// A GRANDPA message for a substrate chain.
 pub type Message<Block> = grandpa::Message<<Block as BlockT>::Hash, NumberFor<Block>>;
+
 /// A signed message.
 pub type SignedMessage<Block> = grandpa::SignedMessage<
 	<Block as BlockT>::Hash,
@@ -123,33 +125,47 @@ pub type SignedMessage<Block> = grandpa::SignedMessage<
 	AuthorityId,
 >;
 
+/// An ordered set of historical votes.
+pub type HistoricalVotes<Block> = grandpa::HistoricalVotes<
+	<Block as BlockT>::Hash,
+	NumberFor<Block>,
+	AuthoritySignature,
+	AuthorityId,
+>;
+
 /// A primary propose message for this chain's block type.
 pub type PrimaryPropose<Block> = grandpa::PrimaryPropose<<Block as BlockT>::Hash, NumberFor<Block>>;
+
 /// A prevote message for this chain's block type.
 pub type Prevote<Block> = grandpa::Prevote<<Block as BlockT>::Hash, NumberFor<Block>>;
+
 /// A precommit message for this chain's block type.
 pub type Precommit<Block> = grandpa::Precommit<<Block as BlockT>::Hash, NumberFor<Block>>;
+
 /// A catch up message for this chain's block type.
 pub type CatchUp<Block> = grandpa::CatchUp<
 	<Block as BlockT>::Hash,
 	NumberFor<Block>,
 	AuthoritySignature,
 	AuthorityId,
 >;
+
 /// A commit message for this chain's block type.
 pub type Commit<Block> = grandpa::Commit<
 	<Block as BlockT>::Hash,
 	NumberFor<Block>,
 	AuthoritySignature,
 	AuthorityId,
 >;
+
 /// A compact commit message for this chain's block type.
 pub type CompactCommit<Block> = grandpa::CompactCommit<
 	<Block as BlockT>::Hash,
 	NumberFor<Block>,
 	AuthoritySignature,
 	AuthorityId,
 >;
+
 /// A global communication input stream for commits and catch up messages. Not
 /// exposed publicly, used internally to simplify types in the communication
 /// layer.
@@ -663,19 +679,29 @@ pub fn run_grandpa_voter<B, E, Block: BlockT<Hash=H256>, N, RA, SC, X>(
 					// start the new authority set using the block where the
 					// set changed (not where the signal happened!) as the base.
 					let genesis_state = RoundState::genesis((new.canon_hash, new.canon_number));
+
+					// always start at round 0 when changing sets.
+					let completed_round = CompletedRound {
+							number: 0,
+							state: genesis_state,
+							base: (new.canon_hash, new.canon_number),
+							historical_votes: HistoricalVotes::<Block>::new(),
+					};
+
+					let mut rounds = VecDeque::new();
+					rounds.push_back(completed_round);
+
+					let voters = authority_set.inner().read()
+						.current().1.iter().map(|(a, _)| a.clone()).collect();
+
+					let completed_rounds = CompletedRounds::new(
+						rounds,
+						new.set_id,
+						voters,
+					);
 
 					let set_state = VoterSetState::Live {
-						// always start at round 0 when changing sets.
-						completed_rounds: CompletedRounds::new(
-							CompletedRound {
-								number: 0,
-								state: genesis_state,
-								base: (new.canon_hash, new.canon_number),
-								votes: Vec::new(),
-							},
-							new.set_id,
-							&*authority_set.inner().read(),
-						),
+						completed_rounds,
 						current_round: HasVoted::No,
 					};
 

core/finality-grandpa/src/observer.rs

@@ -15,12 +15,14 @@
 // along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::sync::Arc;
+use std::collections::VecDeque;
 
 use futures::prelude::*;
 use futures::future::{self, Loop as FutureLoop};
 
 use grandpa::{
-	BlockNumberOps, Error as GrandpaError, round::State as RoundState, voter, voter_set::VoterSet
+	BlockNumberOps, Error as GrandpaError, round::State as RoundState, voter, voter_set::VoterSet,
+	HistoricalVotes,
 };
 use log::{debug, info, warn};
 
@@ -239,19 +241,26 @@ pub fn run_grandpa_observer<B, E, Block: BlockT<Hash=H256>, N, RA, SC>(
 					// start the new authority set using the block where the
 					// set changed (not where the signal happened!) as the base.
 					let genesis_state = RoundState::genesis((new.canon_hash, new.canon_number));
-
+					let completed_round = CompletedRound {
+						number: 0,
+						state: genesis_state,
+						base: (new.canon_hash, new.canon_number),
+						historical_votes: HistoricalVotes::new(),
+					};
+					let mut rounds = VecDeque::new();
+					rounds.push_back(completed_round);
+					let voters_set = &*authority_set.inner().read();
+					let voters = voters_set
+						.current().1.iter().map(|(a, _)| a.clone()).collect();
+
+					let completed_rounds = CompletedRounds::new(
+						rounds,
+						new.set_id,
+						voters,
+					);
 					let set_state = VoterSetState::Live::<Block> {
 						// always start at round 0 when changing sets.
-						completed_rounds: CompletedRounds::new(
-							CompletedRound {
-								number: 0,
-								state: genesis_state,
-								base: (new.canon_hash, new.canon_number),
-								votes: Vec::new(),
-							},
-							new.set_id,
-							&*authority_set.inner().read(),
-						),
+						completed_rounds,
 						current_round: HasVoted::No,
 					};