Dynamic authority sets in GRANDPA

Cargo.toml

@@ -27,6 +27,7 @@ members = [
 	"core/consensus/rhd",
 	"core/executor",
 	"core/finality-grandpa",
+	"core/finality-grandpa/primitives",
 	"core/keyring",
 	"core/network",
 	"core/primitives",

core/client/db/src/lib.rs

@@ -277,6 +277,18 @@ pub struct BlockImportOperation<Block: BlockT, H: Hasher> {
 	updates: MemoryDB<H>,
 	changes_trie_updates: MemoryDB<H>,
 	pending_block: Option<PendingBlock<Block>>,
+	aux_ops: Vec<(Vec<u8>, Option<Vec<u8>>)>,
+}
+
+impl<Block: BlockT, H: Hasher> BlockImportOperation<Block, H> {
+	fn apply_aux(&mut self, transaction: &mut DBTransaction) {
+		for (key, maybe_val) in self.aux_ops.drain(..) {
+			match maybe_val {
+				Some(val) => transaction.put_vec(columns::AUX, &key, val),
+				None => transaction.delete(columns::AUX, &key),
+			}
+		}
+	}
 }
 
 impl<Block> client::backend::BlockImportOperation<Block, Blake2Hasher>
@@ -348,6 +360,13 @@ where Block: BlockT<Hash=H256>,
 		self.changes_trie_updates = update;
 		Ok(())
 	}
+
+	fn set_aux<I>(&mut self, ops: I) -> Result<(), client::error::Error>
+		where I: IntoIterator<Item=(Vec<u8>, Option<Vec<u8>>)>
+	{
+		self.aux_ops = ops.into_iter().collect();
+		Ok(())
+	}
 }
 
 struct StorageDb<Block: BlockT> {
@@ -605,13 +624,15 @@ impl<Block> client::backend::Backend<Block, Blake2Hasher> for Backend<Block> whe
 			old_state: state,
 			updates: MemoryDB::default(),
 			changes_trie_updates: MemoryDB::default(),
+			aux_ops: Vec::new(),
 		})
 	}
 
 	fn commit_operation(&self, mut operation: Self::BlockImportOperation)
 		-> Result<(), client::error::Error>
 	{
 		let mut transaction = DBTransaction::new();
+		operation.apply_aux(&mut transaction);
 
 		if let Some(pending_block) = operation.pending_block {
 			let hash = pending_block.header.hash();

core/client/db/src/light.rs

@@ -43,6 +43,7 @@ pub(crate) mod columns {
 	pub const HEADER: Option<u32> = Some(2);
 	pub const CACHE: Option<u32> = Some(3);
 	pub const CHT: Option<u32> = Some(4);
+	pub const AUX: Option<u32> = Some(5);
 }
 
 /// Light blockchain storage. Stores most recent headers + CHTs for older headers.
@@ -238,6 +239,7 @@ impl<Block> LightBlockchainStorage<Block> for LightStorage<Block>
 		header: Block::Header,
 		authorities: Option<Vec<AuthorityId>>,
 		leaf_state: NewBlockState,
+		aux_ops: Vec<(Vec<u8>, Option<Vec<u8>>)>,
 	) -> ClientResult<()> {
 		let mut transaction = DBTransaction::new();
 
@@ -253,6 +255,13 @@ impl<Block> LightBlockchainStorage<Block> for LightStorage<Block>
 			::utils::number_and_hash_to_lookup_key(number, hash)
 		};
 
+		for (key, maybe_val) in aux_ops {
+			match maybe_val {
+				Some(val) => transaction.put_vec(columns::AUX, &key, val),
+				None => transaction.delete(columns::AUX, &key),
+			}
+		}
+
 		if leaf_state.is_best() {
 			// handle reorg.
 			{
@@ -427,7 +436,7 @@ pub(crate) mod tests {
 	) -> Hash {
 		let header = prepare_header(parent, number, extrinsics_root);
 		let hash = header.hash();
-		db.import_header(header, authorities, NewBlockState::Best).unwrap();
+		db.import_header(header, authorities, NewBlockState::Best, Vec::new()).unwrap();
 		hash
 	}
 
@@ -439,7 +448,7 @@ pub(crate) mod tests {
 	) -> Hash {
 		let header = prepare_header(parent, number, Default::default());
 		let hash = header.hash();
-		db.import_header(header, authorities, NewBlockState::Best).unwrap();
+		db.import_header(header, authorities, NewBlockState::Best, Vec::new()).unwrap();
 		hash
 	}
 
@@ -451,7 +460,7 @@ pub(crate) mod tests {
 	) -> Hash {
 		let header = prepare_header(parent, number, Default::default());
 		let hash = header.hash();
-		db.import_header(header, authorities, NewBlockState::Final).unwrap();
+		db.import_header(header, authorities, NewBlockState::Final, Vec::new()).unwrap();
 		hash
 	}
 
@@ -463,7 +472,7 @@ pub(crate) mod tests {
 	) -> Hash {
 		let header = prepare_header(parent, number, Default::default());
 		let hash = header.hash();
-		db.import_header(header, authorities, NewBlockState::Normal).unwrap();
+		db.import_header(header, authorities, NewBlockState::Normal, Vec::new()).unwrap();
 		hash
 	}
 

core/client/src/backend.rs

@@ -75,6 +75,9 @@ where
 	fn reset_storage(&mut self, top: StorageMap, children: ChildrenStorageMap) -> error::Result<H::Out>;
 	/// Inject changes trie data into the database.
 	fn update_changes_trie(&mut self, update: MemoryDB<H>) -> error::Result<()>;
+	/// Update auxiliary keys. Values are `None` if should be deleted.
+	fn set_aux<I>(&mut self, ops: I) -> error::Result<()>
+		where I: IntoIterator<Item=(Vec<u8>, Option<Vec<u8>>)>;
 }
 
 /// Client backend. Manages the data layer.

core/client/src/client.rs

@@ -502,6 +502,7 @@ impl<B, E, Block> Client<B, E, Block> where
 		body: Option<Vec<Block::Extrinsic>>,
 		authorities: Option<Vec<AuthorityId>>,
 		finalized: bool,
+		aux: Vec<(Vec<u8>, Option<Vec<u8>>)>,
 	) -> error::Result<ImportResult> {
 		let parent_hash = import_headers.post().parent_hash().clone();
 		match self.backend.blockchain().status(BlockId::Hash(hash))? {
@@ -592,6 +593,8 @@ impl<B, E, Block> Client<B, E, Block> where
 		if let Some(Some(changes_update)) = changes_update {
 			transaction.update_changes_trie(changes_update)?;
 		}
+
+		transaction.set_aux(aux)?;
 		self.backend.commit_operation(transaction)?;
 
 		if make_notifications {
@@ -798,7 +801,9 @@ impl<B, E, Block> Client<B, E, Block> where
 	/// TODO [snd] possibly implement this on blockchain::Backend and just redirect here
 	/// Returns `Ok(None)` if `target_hash` is not found in search space.
 	/// TODO [snd] write down time complexity
-	pub fn best_containing(&self, target_hash: Block::Hash, maybe_max_number: Option<NumberFor<Block>>) -> error::Result<Option<Block::Hash>> {
+	pub fn best_containing(&self, target_hash: Block::Hash, maybe_max_number: Option<NumberFor<Block>>)
+		-> error::Result<Option<Block::Hash>>
+	{
 		let target_header = {
 			match self.backend.blockchain().header(BlockId::Hash(target_hash))? {
 				Some(x) => x,
@@ -913,7 +918,7 @@ impl<B, E, Block> consensus::BlockImport<Block> for Client<B, E, Block> where
 			post_runtime_digests,
 			body,
 			finalized,
-			..
+			auxiliary,
 		} = import_block;
 		let parent_hash = header.parent_hash().clone();
 
@@ -945,6 +950,7 @@ impl<B, E, Block> consensus::BlockImport<Block> for Client<B, E, Block> where
 			body,
 			new_authorities,
 			finalized,
+			auxiliary,
 		);
 
 		*self.importing_block.write() = None;

core/client/src/in_mem.rs

@@ -96,6 +96,7 @@ struct BlockchainStorage<Block: BlockT> {
 	genesis_hash: Block::Hash,
 	cht_roots: HashMap<NumberFor<Block>, Block::Hash>,
 	leaves: LeafSet<Block::Hash, NumberFor<Block>>,
+	aux: HashMap<Vec<u8>, Vec<u8>>,
 }
 
 /// In-memory blockchain. Supports concurrent reads.
@@ -144,6 +145,7 @@ impl<Block: BlockT> Blockchain<Block> {
 				genesis_hash: Default::default(),
 				cht_roots: HashMap::new(),
 				leaves: LeafSet::new(),
+				aux: HashMap::new(),
 			}));
 		Blockchain {
 			storage: storage.clone(),
@@ -247,6 +249,16 @@ impl<Block: BlockT> Blockchain<Block> {
 		self.storage.write().finalized_hash = hash;
 		Ok(())
 	}
+
+	fn write_aux(&self, ops: Vec<(Vec<u8>, Option<Vec<u8>>)>) {
+		let mut storage = self.storage.write();
+		for (k, v) in ops {
+			match v {
+				Some(v) => storage.aux.insert(k, v),
+				None => storage.aux.remove(&k),
+			};
+		}
+	}
 }
 
 impl<Block: BlockT> HeaderBackend<Block> for Blockchain<Block> {
@@ -320,6 +332,7 @@ impl<Block: BlockT> light::blockchain::Storage<Block> for Blockchain<Block>
 		header: Block::Header,
 		authorities: Option<Vec<AuthorityId>>,
 		state: NewBlockState,
+		aux_ops: Vec<(Vec<u8>, Option<Vec<u8>>)>,
 	) -> error::Result<()> {
 		let hash = header.hash();
 		let parent_hash = *header.parent_hash();
@@ -328,6 +341,7 @@ impl<Block: BlockT> light::blockchain::Storage<Block> for Blockchain<Block>
 			self.cache.insert(parent_hash, authorities);
 		}
 
+		self.write_aux(aux_ops);
 		Ok(())
 	}
 
@@ -356,6 +370,7 @@ pub struct BlockImportOperation<Block: BlockT, H: Hasher> {
 	old_state: InMemory<H>,
 	new_state: Option<InMemory<H>>,
 	changes_trie_update: Option<MemoryDB<H>>,
+	aux: Option<Vec<(Vec<u8>, Option<Vec<u8>>)>>,
 }
 
 impl<Block, H> backend::BlockImportOperation<Block, H> for BlockImportOperation<Block, H>
@@ -426,6 +441,13 @@ where
 		self.new_state = Some(InMemory::from(transaction));
 		Ok(root)
 	}
+
+	fn set_aux<I>(&mut self, ops: I) -> error::Result<()>
+		where I: IntoIterator<Item=(Vec<u8>, Option<Vec<u8>>)>
+	{
+		self.aux = Some(ops.into_iter().collect());
+		Ok(())
+	}
 }
 
 /// In-memory backend. Keeps all states and blocks in memory. Useful for testing.
@@ -438,7 +460,6 @@ where
 	states: RwLock<HashMap<Block::Hash, InMemory<H>>>,
 	changes_trie_storage: InMemoryChangesTrieStorage<H>,
 	blockchain: Blockchain<Block>,
-	aux: RwLock<HashMap<Vec<u8>, Vec<u8>>>,
 }
 
 impl<Block, H> Backend<Block, H>
@@ -453,7 +474,6 @@ where
 			states: RwLock::new(HashMap::new()),
 			changes_trie_storage: InMemoryChangesTrieStorage::new(),
 			blockchain: Blockchain::new(),
-			aux: RwLock::new(HashMap::new()),
 		}
 	}
 }
@@ -481,6 +501,7 @@ where
 			old_state: state,
 			new_state: None,
 			changes_trie_update: None,
+			aux: None,
 		})
 	}
 
@@ -508,6 +529,10 @@ where
 				self.blockchain.cache.insert(parent_hash, operation.pending_authorities);
 			}
 		}
+
+		if let Some(ops) = operation.aux {
+			self.blockchain.write_aux(ops);
+		}
 		Ok(())
 	}
 
@@ -535,18 +560,18 @@ where
 	}
 
 	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 aux = self.aux.write();
+		let mut storage = self.blockchain.storage.write();
 		for (k, v) in insert {
-			aux.insert(k.to_vec(), v.to_vec());
+			storage.aux.insert(k.to_vec(), v.to_vec());
 		}
 		for k in delete {
-			aux.remove(*k);
+			storage.aux.remove(*k);
 		}
 		Ok(())
 	}
 
 	fn get_aux(&self, key: &[u8]) -> error::Result<Option<Vec<u8>>> {
-		Ok(self.aux.read().get(key).cloned())
+		Ok(self.blockchain.storage.read().aux.get(key).cloned())
 	}
 }