Approve multiple candidates with a single signature

node/core/approval-voting/src/approval_db/v2/migration_helpers.rs

@@ -51,6 +51,7 @@ fn make_block_entry(
 		approved_bitfield: make_bitvec(candidates.len()),
 		candidates,
 		children: Vec::new(),
+		candidates_pending_signature: Default::default(),
 	}
 }
 

node/core/approval-voting/src/approval_db/v2/mod.rs

@@ -21,8 +21,8 @@ use polkadot_node_primitives::approval::{v1::DelayTranche, v2::AssignmentCertV2}
 use polkadot_node_subsystem::{SubsystemError, SubsystemResult};
 use polkadot_node_subsystem_util::database::{DBTransaction, Database};
 use polkadot_primitives::{
-	BlockNumber, CandidateHash, CandidateReceipt, CoreIndex, GroupIndex, Hash, SessionIndex,
-	ValidatorIndex, ValidatorSignature,
+	BlockNumber, CandidateHash, CandidateIndex, CandidateReceipt, CoreIndex, GroupIndex, Hash,
+	SessionIndex, ValidatorIndex, ValidatorSignature,
 };
 
 use sp_consensus_slots::Slot;
@@ -238,6 +238,17 @@ pub struct BlockEntry {
 	// block. The block can be considered approved if the bitfield has all bits set to `true`.
 	pub approved_bitfield: Bitfield,
 	pub children: Vec<Hash>,
+	// A list of candidates that has been approved, but we didn't not sign and
+	// advertise the vote yet.
+	pub candidates_pending_signature: BTreeMap<CandidateIndex, CandidateSigningContext>,
+}
+
+#[derive(Encode, Decode, Debug, Clone, PartialEq)]
+
+/// Context needed for creating an approval signature  for a given candidate.
+pub struct CandidateSigningContext {
+	pub candidate_hash: CandidateHash,
+	pub approved_time_since_unix_epoch: u128,
 }
 
 impl From<crate::Tick> for Tick {

node/core/approval-voting/src/approval_db/v2/tests.rs

@@ -56,6 +56,7 @@ fn make_block_entry(
 		approved_bitfield: make_bitvec(candidates.len()),
 		candidates,
 		children: Vec::new(),
+		candidates_pending_signature: Default::default(),
 	}
 }
 

node/core/approval-voting/src/approvals_timers.rs

@@ -0,0 +1,80 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot 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.
+
+// Polkadot 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 Polkadot.  If not, see <http://www.gnu.org/licenses/>.
+
+//! A simple implementation of a timer per block hash .
+//!
+use std::{collections::HashSet, task::Poll, time::Duration};
+
+use futures::{
+	future::BoxFuture,
+	stream::{FusedStream, FuturesUnordered},
+	Stream, StreamExt,
+};
+use futures_timer::Delay;
+use polkadot_primitives::{Hash, ValidatorIndex};
+// A list of delayed futures that gets triggered when the waiting time has expired and it is
+// time to sign the candidate.
+// We have a timer per relay-chain block.
+#[derive(Default)]
+pub struct SignApprovalsTimers {
+	timers: FuturesUnordered<BoxFuture<'static, (Hash, ValidatorIndex)>>,
+	blocks: HashSet<Hash>,
+}
+
+impl SignApprovalsTimers {
+	/// Starts a single timer per block hash
+	///
+	/// Guarantees that if a timer already exits for the give block hash,
+	/// no additional timer is started.
+	pub fn maybe_start_timer_for_block(
+		&mut self,
+		timer_duration_ms: u32,
+		block_hash: Hash,
+		validator_index: ValidatorIndex,
+	) {
+		if self.blocks.insert(block_hash) {
+			let delay = Delay::new(Duration::from_millis(timer_duration_ms as _));
+			self.timers.push(Box::pin(async move {
+				delay.await;
+				(block_hash, validator_index)
+			}));
+		}
+	}
+}
+
+impl Stream for SignApprovalsTimers {
+	type Item = (Hash, ValidatorIndex);
+
+	fn poll_next(
+		mut self: std::pin::Pin<&mut Self>,
+		cx: &mut std::task::Context<'_>,
+	) -> std::task::Poll<Option<Self::Item>> {
+		let poll_result = self.timers.poll_next_unpin(cx);
+		match poll_result {
+			Poll::Ready(Some(result)) => {
+				self.blocks.remove(&result.0);
+				Poll::Ready(Some(result))
+			},
+			_ => poll_result,
+		}
+	}
+}
+
+impl FusedStream for SignApprovalsTimers {
+	fn is_terminated(&self) -> bool {
+		self.timers.is_terminated()
+	}
+}

node/core/approval-voting/src/import.rs

@@ -511,6 +511,7 @@ pub(crate) async fn handle_new_head<Context, B: Backend>(
 				.collect(),
 			approved_bitfield,
 			children: Vec::new(),
+			candidates_pending_signature: Default::default(),
 		};
 
 		gum::trace!(
@@ -1264,6 +1265,7 @@ pub(crate) mod tests {
 				candidates: Vec::new(),
 				approved_bitfield: Default::default(),
 				children: Vec::new(),
+				candidates_pending_signature: Default::default(),
 			}
 			.into(),
 		);