Punish offline validators, aura-style (#1216)

* make offline-reporting infrastructure more generic

* add a listener-trait for watching when the timestamp has been set

* prevent inclusion of empty offline reports

* add test for exclusion

* generate aura-offline reports

* ability to slash many times for being offline "multiple" times

* Logic for punishing validators for missing aura steps

* stub tests

* pave way for verification of timestamp vs slot

* alter aura import queue to wait for timestamp

* check timestamp matches seal

* do inherent check properly

* service compiles

* all tests compile

* test srml-aura logic

* aura tests pass

* everything builds

* some more final tweaks to block authorship for aura

* switch to manual delays before step

* restore substrate-consensus-aura to always std and address grumbles

* update some state roots in executor tests

* node-executor tests pass

* get most tests passing

* address grumbles

substrate/core/client/src/backend.rs

@@ -79,6 +79,20 @@ pub trait BlockImportOperation<Block, H> where
 		where I: IntoIterator<Item=(Vec<u8>, Option<Vec<u8>>)>;
 }
 
+/// Provides access to an auxiliary database.
+pub trait AuxStore {
+	/// Insert auxiliary data into key-value store. Deletions occur after insertions.
+	fn insert_aux<
+		'a,
+		'b: 'a,
+		'c: 'a,
+		I: IntoIterator<Item=&'a(&'c [u8], &'c [u8])>,
+		D: IntoIterator<Item=&'a &'b [u8]>,
+	>(&self, insert: I, delete: D) -> error::Result<()>;
+	/// Query auxiliary data from key-value store.
+	fn get_aux(&self, key: &[u8]) -> error::Result<Option<Vec<u8>>>;
+}
+
 /// Client backend. Manages the data layer.
 ///
 /// Note on state pruning: while an object from `state_at` is alive, the state
@@ -87,7 +101,7 @@ pub trait BlockImportOperation<Block, H> where
 ///
 /// The same applies for live `BlockImportOperation`s: while an import operation building on a parent `P`
 /// is alive, the state for `P` should not be pruned.
-pub trait Backend<Block, H>: Send + Sync where
+pub trait Backend<Block, H>: AuxStore + Send + Sync where
 	Block: BlockT,
 	H: Hasher<Out=Block::Hash>,
 {
@@ -117,10 +131,22 @@ pub trait Backend<Block, H>: Send + Sync where
 	/// Attempts to revert the chain by `n` blocks. Returns the number of blocks that were
 	/// successfully reverted.
 	fn revert(&self, n: NumberFor<Block>) -> error::Result<NumberFor<Block>>;
+
 	/// Insert auxiliary data into key-value store.
-	fn insert_aux<'a, 'b: 'a, 'c: 'a, I: IntoIterator<Item=&'a(&'c [u8], &'c [u8])>, D: IntoIterator<Item=&'a &'b [u8]>>(&self, insert: I, delete: D) -> error::Result<()>;
+	fn insert_aux<
+		'a,
+		'b: 'a,
+		'c: 'a,
+		I: IntoIterator<Item=&'a(&'c [u8], &'c [u8])>,
+		D: IntoIterator<Item=&'a &'b [u8]>,
+	>(&self, insert: I, delete: D) -> error::Result<()>
+	{
+		AuxStore::insert_aux(self, insert, delete)
+	}
 	/// Query auxiliary data from key-value store.
-	fn get_aux(&self, key: &[u8]) -> error::Result<Option<Vec<u8>>>;
+	fn get_aux(&self, key: &[u8]) -> error::Result<Option<Vec<u8>>> {
+		AuxStore::get_aux(self, key)
+	}
 }
 
 /// Mark for all Backend implementations, that are making use of state data, stored locally.

substrate/core/client/src/client.rs

@@ -1170,6 +1170,27 @@ impl<B, E, Block, RA> BlockBody<Block> for Client<B, E, Block, RA>
 	}
 }
 
+impl<B, E, Block, RA> backend::AuxStore for Client<B, E, Block, RA>
+	where
+		B: backend::Backend<Block, Blake2Hasher>,
+		E: CallExecutor<Block, Blake2Hasher>,
+		Block: BlockT<Hash=H256>,
+{
+	/// Insert auxiliary data into key-value store.
+	fn insert_aux<
+		'a,
+		'b: 'a,
+		'c: 'a,
+		I: IntoIterator<Item=&'a(&'c [u8], &'c [u8])>,
+		D: IntoIterator<Item=&'a &'b [u8]>,
+	>(&self, insert: I, delete: D) -> error::Result<()> {
+		::backend::AuxStore::insert_aux(&*self.backend, insert, delete)
+	}
+	/// Query auxiliary data from key-value store.
+	fn get_aux(&self, key: &[u8]) -> error::Result<Option<Vec<u8>>> {
+		::backend::AuxStore::get_aux(&*self.backend, key)
+	}
+}
 #[cfg(test)]
 pub(crate) mod tests {
 	use std::collections::HashMap;

substrate/core/client/src/in_mem.rs

@@ -498,6 +498,34 @@ where
 	}
 }
 
+impl<Block, H> backend::AuxStore for Backend<Block, H>
+where
+	Block: BlockT,
+	H: Hasher<Out=Block::Hash>,
+	H::Out: HeapSizeOf + Ord,
+{
+	fn insert_aux<
+		'a,
+		'b: 'a,
+		'c: 'a,
+		I: IntoIterator<Item=&'a(&'c [u8], &'c [u8])>,
+		D: IntoIterator<Item=&'a &'b [u8]>,
+	>(&self, insert: I, delete: D) -> error::Result<()> {
+		let mut storage = self.blockchain.storage.write();
+		for (k, v) in insert {
+			storage.aux.insert(k.to_vec(), v.to_vec());
+		}
+		for k in delete {
+			storage.aux.remove(*k);
+		}
+		Ok(())
+	}
+
+	fn get_aux(&self, key: &[u8]) -> error::Result<Option<Vec<u8>>> {
+		Ok(self.blockchain.storage.read().aux.get(key).cloned())
+	}
+}
+
 impl<Block, H> backend::Backend<Block, H> for Backend<Block, H>
 where
 	Block: BlockT,
@@ -578,21 +606,6 @@ where
 	fn revert(&self, _n: NumberFor<Block>) -> error::Result<NumberFor<Block>> {
 		Ok(As::sa(0))
 	}
-
-	fn insert_aux<'a, 'b: 'a, 'c: 'a, I: IntoIterator<Item=&'a (&'c [u8], &'c [u8])>, D: IntoIterator<Item=&'a &'b [u8]>>(&self, insert: I, delete: D) -> error::Result<()> {
-		let mut storage = self.blockchain.storage.write();
-		for (k, v) in insert {
-			storage.aux.insert(k.to_vec(), v.to_vec());
-		}
-		for k in delete {
-			storage.aux.remove(*k);
-		}
-		Ok(())
-	}
-
-	fn get_aux(&self, key: &[u8]) -> error::Result<Option<Vec<u8>>> {
-		Ok(self.blockchain.storage.read().aux.get(key).cloned())
-	}
 }
 
 impl<Block, H> backend::LocalBackend<Block, H> for Backend<Block, H>

substrate/core/client/src/light/backend.rs

@@ -70,6 +70,22 @@ impl<S, F> Backend<S, F> {
 	}
 }
 
+impl<S, F> ::backend::AuxStore for Backend<S, F> {
+	fn insert_aux<
+		'a,
+		'b: 'a,
+		'c: 'a,
+		I: IntoIterator<Item=&'a(&'c [u8], &'c [u8])>,
+		D: IntoIterator<Item=&'a &'b [u8]>,
+	>(&self, _insert: I, _delete: D) -> ClientResult<()> {
+		Err(ClientErrorKind::NotAvailableOnLightClient.into())
+	}
+
+	fn get_aux(&self, _key: &[u8]) -> ClientResult<Option<Vec<u8>>> {
+		Err(ClientErrorKind::NotAvailableOnLightClient.into())
+	}
+}
+
 impl<S, F, Block, H> ClientBackend<Block, H> for Backend<S, F> where
 	Block: BlockT,
 	S: BlockchainStorage<Block>,
@@ -131,14 +147,6 @@ impl<S, F, Block, H> ClientBackend<Block, H> for Backend<S, F> where
 	fn revert(&self, _n: NumberFor<Block>) -> ClientResult<NumberFor<Block>> {
 		Err(ClientErrorKind::NotAvailableOnLightClient.into())
 	}
-
-	fn insert_aux<'a, 'b: 'a, 'c: 'a, I: IntoIterator<Item=&'a (&'c [u8], &'c [u8])>, D: IntoIterator<Item=&'a &'b [u8]>>(&self, _insert: I, _delete: D) -> ClientResult<()> {
-		Err(ClientErrorKind::NotAvailableOnLightClient.into())
-	}
-
-	fn get_aux(&self, _key: &[u8]) -> ClientResult<Option<Vec<u8>>> {
-		Err(ClientErrorKind::NotAvailableOnLightClient.into())
-	}
 }
 
 impl<S, F, Block, H> RemoteBackend<Block, H> for Backend<S, F>