A more comprehensive model for PoV-Blocks and Candidate receipts (#843)

* encode the candidate statement as only the hash

* refactor CandidateReceipt and CollationInfo

* introduce an abridged candidate receipt type

* erasure coding stores candidate receipt

* store omitted data instead and introduce AvailableData type

* refactor availability-store schema

* tweak schema and APIs a bit more

* get availability-store tests passing

* accept AbridgedCandidateReceipt in `set_heads`

* change statement type in primitives to be hash-only

* fix parachains runtime tests

* fix bad merge

* rewrite validation pipeline

* remove evaluation module

* use abridged candidate hash as canonical

* statement table uses abridged candidate receipts

* kill availability_store::Data struct

* port shared table to new validation pipelines

* extract full validation pipeline to helper

* remove old validation pipeline from collation module

* polkadot-validation compiles

* polkadot-validation tests compile

* make local collation available in validation service

* port legacy network code

* polkadot-network fully ported

* network: ensure fresh statement is propagated

* remove pov_block_hash from LocalValidationData

* remove candidate_hash field from AttestedCandidate and update runtime

* port runtimes to new ParachainHost definition

* port over polkadot-collator

* fix test compilation

* better fix

* remove unrelated validation work dispatch fix

* address grumbles

* fix equality check

polkadot/availability-store/src/store.rs

@@ -21,8 +21,11 @@ use codec::{Encode, Decode};
 use polkadot_erasure_coding::{self as erasure};
 use polkadot_primitives::{
 	Hash,
-	parachain::{BlockData, CandidateReceipt, ErasureChunk},
+	parachain::{
+		ErasureChunk, AvailableData, AbridgedCandidateReceipt,
+	},
 };
+use parking_lot::Mutex;
 
 use log::{trace, warn};
 use std::collections::HashSet;
@@ -30,7 +33,7 @@ use std::sync::Arc;
 use std::iter::FromIterator;
 use std::io;
 
-use crate::{LOG_TARGET, Data, Config};
+use crate::{LOG_TARGET, Config, ExecutionData};
 
 mod columns {
 	pub const DATA: u32 = 0;
@@ -41,42 +44,51 @@ mod columns {
 #[derive(Clone)]
 pub struct Store {
 	inner: Arc<dyn KeyValueDB>,
+	candidate_descendents_lock: Arc<Mutex<()>>
 }
 
-fn block_data_key(relay_parent: &Hash, block_data_hash: &Hash) -> Vec<u8> {
-	(relay_parent, block_data_hash, 0i8).encode()
+// data keys
+fn execution_data_key(candidate_hash: &Hash) -> Vec<u8> {
+	(candidate_hash, 0i8).encode()
 }
 
-fn erasure_chunks_key(relay_parent: &Hash, block_data_hash: &Hash) -> Vec<u8> {
-	(relay_parent, block_data_hash, 1i8).encode()
-}
-
-fn awaited_chunks_key() -> Vec<u8> {
-	"awaited_chunks_key".encode()
-}
-
-fn available_chunks_key(relay_parent: &Hash, erasure_root: &Hash) -> Vec<u8> {
-	(relay_parent, erasure_root, 2i8).encode()
-}
-
-fn block_to_candidate_key(block_data_hash: &Hash) -> Vec<u8> {
-	(block_data_hash, 1i8).encode()
+fn erasure_chunks_key(candidate_hash: &Hash) -> Vec<u8> {
+	(candidate_hash, 1i8).encode()
 }
 
 fn candidate_key(candidate_hash: &Hash) -> Vec<u8> {
 	(candidate_hash, 2i8).encode()
 }
 
-fn validator_index_and_n_validators_key(relay_parent: &Hash) -> Vec<u8> {
-	(relay_parent, 3i8).encode()
+fn available_chunks_key(relay_parent: &Hash, erasure_root: &Hash) -> Vec<u8> {
+	(relay_parent, erasure_root, 3i8).encode()
 }
 
-fn candidates_in_relay_chain_block_key(relay_block: &Hash) -> Vec<u8> {
+fn candidates_with_relay_parent_key(relay_block: &Hash) -> Vec<u8> {
 	(relay_block, 4i8).encode()
 }
 
-fn erasure_roots_in_relay_chain_block_key(relay_block: &Hash) -> Vec<u8> {
-	(relay_block, 5i8).encode()
+// meta keys
+fn awaited_chunks_key() -> [u8; 14] {
+	*b"awaited_chunks"
+}
+
+fn validator_index_and_n_validators_key(relay_parent: &Hash) -> Vec<u8> {
+	(relay_parent, 1i8).encode()
+}
+
+/// An entry in the awaited frontier of chunks we are interested in.
+#[derive(Encode, Decode, Debug, Hash, PartialEq, Eq, Clone)]
+pub struct AwaitedFrontierEntry {
+	/// The relay-chain parent block hash.
+	pub relay_parent: Hash,
+	/// The erasure-chunk trie root we are comparing against.
+	///
+	/// We index by erasure-root because there may be multiple candidates
+	/// with the same erasure root.
+	pub erasure_root: Hash,
+	/// The index of the validator we represent.
+	pub validator_index: u32,
 }
 
 impl Store {
@@ -103,6 +115,7 @@ impl Store {
 
 		Ok(Store {
 			inner: Arc::new(db),
+			candidate_descendents_lock: Arc::new(Mutex::new(())),
 		})
 	}
 
@@ -110,31 +123,37 @@ impl Store {
 	pub(super) fn new_in_memory() -> Self {
 		Store {
 			inner: Arc::new(::kvdb_memorydb::create(columns::NUM_COLUMNS)),
+			candidate_descendents_lock: Arc::new(Mutex::new(())),
 		}
 	}
 
 	/// Make some data available provisionally.
-	pub(crate) fn make_available(&self, data: Data) -> io::Result<()> {
+	pub(crate) fn make_available(&self, candidate_hash: Hash, available_data: AvailableData)
+		-> io::Result<()>
+	{
 		let mut tx = DBTransaction::new();
 
-		// note the meta key.
-		let mut v = self.query_inner(columns::META, data.relay_parent.as_ref()).unwrap_or(Vec::new());
-		v.push(data.block_data.hash());
-		tx.put_vec(columns::META, &data.relay_parent[..], v.encode());
+		// at the moment, these structs are identical. later, we will also
+		// keep outgoing message queues available, and these are not needed
+		// for execution.
+		let AvailableData { pov_block, omitted_validation } = available_data;
+		let execution_data = ExecutionData {
+			pov_block,
+			omitted_validation,
+		};
 
 		tx.put_vec(
 			columns::DATA,
-			block_data_key(&data.relay_parent, &data.block_data.hash()).as_slice(),
-			data.block_data.encode()
+			execution_data_key(&candidate_hash).as_slice(),
+			execution_data.encode(),
 		);
 
 		self.inner.write(tx)
 	}
 
-	/// Get a set of all chunks we are waiting for grouped by
-	/// `(relay_parent, erasure_root, candidate_hash, our_id)`.
-	pub fn awaited_chunks(&self) -> Option<HashSet<(Hash, Hash, Hash, u32)>> {
-		self.query_inner(columns::META, &awaited_chunks_key()).map(|vec: Vec<(Hash, Hash, Hash, u32)>| {
+	/// Get a set of all chunks we are waiting for.
+	pub fn awaited_chunks(&self) -> Option<HashSet<AwaitedFrontierEntry>> {
+		self.query_inner(columns::META, &awaited_chunks_key()).map(|vec: Vec<AwaitedFrontierEntry>| {
 			HashSet::from_iter(vec.into_iter())
 		})
 	}
@@ -147,60 +166,49 @@ impl Store {
 	/// This method modifies the erasure chunks awaited frontier by adding this validator's
 	/// chunks from `candidates` to it. In order to do so the information about this validator's
 	/// position at parent `relay_parent` should be known to the store prior to calling this
-	/// method, in other words `add_validator_index_and_n_validators` should be called for
+	/// method, in other words `note_validator_index_and_n_validators` should be called for
 	/// the given `relay_parent` before calling this function.
-	pub(crate) fn add_candidates_in_relay_block(
+	pub(crate) fn note_candidates_with_relay_parent(
 		&self,
 		relay_parent: &Hash,
-		candidates: Vec<Hash>,
+		candidates: &[Hash],
 	) -> io::Result<()> {
 		let mut tx = DBTransaction::new();
-		let dbkey = candidates_in_relay_chain_block_key(relay_parent);
+		let dbkey = candidates_with_relay_parent_key(relay_parent);
+
+		// This call can race against another call to `note_candidates_with_relay_parent`
+		// with a different set of descendents.
+		let _lock = self.candidate_descendents_lock.lock();
 
 		if let Some((validator_index, _)) = self.get_validator_index_and_n_validators(relay_parent) {
 			let candidates = candidates.clone();
-			let awaited_frontier: Vec<(Hash, Hash, Hash, u32)> = self
+			let awaited_frontier: Vec<AwaitedFrontierEntry> = self
 				.query_inner(columns::META, &awaited_chunks_key())
 				.unwrap_or_else(|| Vec::new());
 
-			let mut awaited_frontier: HashSet<(Hash, Hash, Hash, u32)> =
+			let mut awaited_frontier: HashSet<AwaitedFrontierEntry> =
 				HashSet::from_iter(awaited_frontier.into_iter());
 
-			awaited_frontier.extend(candidates.into_iter().filter_map(|candidate| {
-				self.get_candidate(&candidate)
-					.map(|receipt| (relay_parent.clone(), receipt.erasure_root, candidate, validator_index))
+			awaited_frontier.extend(candidates.iter().filter_map(|candidate| {
+				self.get_candidate(&candidate).map(|receipt| AwaitedFrontierEntry {
+					relay_parent: relay_parent.clone(),
+					erasure_root: receipt.commitments.erasure_root,
+					validator_index,
+				})
 			}));
 			let awaited_frontier = Vec::from_iter(awaited_frontier.into_iter());
 			tx.put_vec(columns::META, &awaited_chunks_key(), awaited_frontier.encode());
 		}
-		tx.put_vec(columns::DATA, &dbkey, candidates.encode());
 
-		self.inner.write(tx)
-	}
-
-	/// Qery which candidates were included in the relay chain block by block's parent.
-	pub fn get_candidates_in_relay_block(&self, relay_block: &Hash) -> Option<Vec<Hash>> {
-		let dbkey = candidates_in_relay_chain_block_key(relay_block);
-
-		self.query_inner(columns::DATA, &dbkey)
-	}
-
-	/// Adds a set of erasure chunk roots that were included in a relay block by block's parent.
-	pub(crate) fn add_erasure_roots_in_relay_block(
-		&self,
-		relay_parent: &Hash,
-		erasure_roots: Vec<Hash>,
-	) -> io::Result<()> {
-		let mut tx = DBTransaction::new();
-		let dbkey = erasure_roots_in_relay_chain_block_key(relay_parent);
-
-		tx.put_vec(columns::DATA, &dbkey, erasure_roots.encode());
+		let mut descendent_candidates = self.get_candidates_with_relay_parent(relay_parent);
+		descendent_candidates.extend(candidates.iter().cloned());
+		tx.put_vec(columns::DATA, &dbkey, descendent_candidates.encode());
 
 		self.inner.write(tx)
 	}
 
 	/// Make a validator's index and a number of validators at a relay parent available.
-	pub(crate) fn add_validator_index_and_n_validators(
+	pub(crate) fn note_validator_index_and_n_validators(
 		&self,
 		relay_parent: &Hash,
 		validator_index: u32,
@@ -215,7 +223,7 @@ impl Store {
 	}
 
 	/// Query a validator's index and n_validators by relay parent.
-	pub fn get_validator_index_and_n_validators(&self, relay_parent: &Hash) -> Option<(u32, u32)> {
+	pub(crate) fn get_validator_index_and_n_validators(&self, relay_parent: &Hash) -> Option<(u32, u32)> {
 		let dbkey = validator_index_and_n_validators_key(relay_parent);
 
 		self.query_inner(columns::META, &dbkey)
@@ -224,11 +232,9 @@ impl Store {
 	/// Add a set of chunks.
 	///
 	/// The same as `add_erasure_chunk` but adds a set of chunks in one atomic transaction.
-	/// Checks that all chunks have the same `relay_parent`, `block_data_hash` and `parachain_id` fields.
 	pub fn add_erasure_chunks<I>(
 		&self,
 		n_validators: u32,
-		relay_parent: &Hash,
 		candidate_hash: &Hash,
 		chunks: I,
 	) -> io::Result<()>
@@ -236,16 +242,19 @@ impl Store {
 	{
 		if let Some(receipt) = self.get_candidate(candidate_hash) {
 			let mut tx = DBTransaction::new();
-			let dbkey = erasure_chunks_key(relay_parent, &receipt.block_data_hash);
+			let dbkey = erasure_chunks_key(candidate_hash);
 
 			let mut v = self.query_inner(columns::DATA, &dbkey).unwrap_or(Vec::new());
 
-			let av_chunks_key = available_chunks_key(relay_parent, &receipt.erasure_root);
+			let av_chunks_key = available_chunks_key(
+				&receipt.relay_parent,
+				&receipt.commitments.erasure_root,
+			);
 			let mut have_chunks = self.query_inner(columns::META, &av_chunks_key).unwrap_or(Vec::new());
 
-			let awaited_frontier: Option<Vec<(Hash, Hash, Hash, u32)>> = self.query_inner(
+			let awaited_frontier: Option<Vec<AwaitedFrontierEntry>> = self.query_inner(
 				columns::META,
-				&awaited_chunks_key()
+				&awaited_chunks_key(),
 			);
 
 			for chunk in chunks.into_iter() {
@@ -256,31 +265,23 @@ impl Store {
 			}
 
 			if let Some(mut awaited_frontier) = awaited_frontier {
-				awaited_frontier.retain(|&(p, r, c, index)| {
+				awaited_frontier.retain(|entry| {
 					!(
-						*relay_parent == p &&
-						r == receipt.erasure_root &&
-						c == receipt.hash() &&
-						have_chunks.contains(&index)
+						entry.relay_parent == receipt.relay_parent &&
+						entry.erasure_root == receipt.commitments.erasure_root &&
+						have_chunks.contains(&entry.validator_index)
 					)
 				});
 				tx.put_vec(columns::META, &awaited_chunks_key(), awaited_frontier.encode());
 			}
 
-			// If therea are no block data and messages in the store at this point,
+			// If therea are no block data in the store at this point,
 			// check that they can be reconstructed now and add them to store if they can.
-			if let Ok(None) = self.inner.get(
-				columns::DATA,
-				&block_data_key(&relay_parent, &receipt.block_data_hash)
-			) {
-				if let Ok(block_data) = erasure::reconstruct(
+			if self.execution_data(&candidate_hash).is_none() {
+				if let Ok(available_data) = erasure::reconstruct(
 					n_validators as usize,
 					v.iter().map(|chunk| (chunk.chunk.as_ref(), chunk.index as usize))) {
-					self.make_available(Data {
-						relay_parent: *relay_parent,
-						parachain_id: receipt.parachain_index,
-						block_data,
-					})?;
+					self.make_available(*candidate_hash, available_data)?;
 				}
 			}
 
@@ -294,14 +295,13 @@ impl Store {
 		}
 	}
 
-	/// Queries an erasure chunk by its block's parent and hash and index.
+	/// Queries an erasure chunk by its block's relay-parent, the candidate hash, and index.
 	pub fn get_erasure_chunk(
 		&self,
-		relay_parent: &Hash,
-		block_data_hash: Hash,
+		candidate_hash: &Hash,
 		index: usize,
 	) -> Option<ErasureChunk> {
-		self.query_inner(columns::DATA, &erasure_chunks_key(&relay_parent, &block_data_hash))
+		self.query_inner(columns::DATA, &erasure_chunks_key(candidate_hash))
 			.and_then(|chunks: Vec<ErasureChunk>| {
 				chunks.iter()
 				.find(|chunk: &&ErasureChunk| chunk.index == index as u32)
@@ -310,70 +310,66 @@ impl Store {
 	}
 
 	/// Stores a candidate receipt.
-	pub fn add_candidate(&self, receipt: &CandidateReceipt) -> io::Result<()> {
-		let dbkey = candidate_key(&receipt.hash());
+	pub fn add_candidate(
+		&self,
+		receipt: &AbridgedCandidateReceipt,
+	) -> io::Result<()> {
+		let candidate_hash = receipt.hash();
+		let dbkey = candidate_key(&candidate_hash);
 		let mut tx = DBTransaction::new();
 
 		tx.put_vec(columns::DATA, &dbkey, receipt.encode());
-		tx.put_vec(columns::META, &block_to_candidate_key(&receipt.block_data_hash), receipt.hash().encode());
 
 		self.inner.write(tx)
 	}
 
-	/// Queries a candidate receipt by it's hash.
-	pub fn get_candidate(&self, candidate_hash: &Hash) -> Option<CandidateReceipt> {
+	/// Queries a candidate receipt by the relay parent hash and its hash.
+	pub(crate) fn get_candidate(&self, candidate_hash: &Hash)
+		-> Option<AbridgedCandidateReceipt>
+	{
 		self.query_inner(columns::DATA, &candidate_key(candidate_hash))
 	}
 
 	/// Note that a set of candidates have been included in a finalized block with given hash and parent hash.
-	pub fn candidates_finalized(
+	pub(crate) fn candidates_finalized(
 		&self,
-		parent: Hash,
+		relay_parent: Hash,
 		finalized_candidates: HashSet<Hash>,
 	) -> io::Result<()> {
 		let mut tx = DBTransaction::new();
 
-		let v = self.query_inner(columns::META, &parent[..]).unwrap_or(Vec::new());
-		tx.delete(columns::META, &parent[..]);
-
-		let awaited_frontier: Option<Vec<(Hash, Hash, Hash, u32)>> = self
+		let awaited_frontier: Option<Vec<AwaitedFrontierEntry>> = self
 			.query_inner(columns::META, &awaited_chunks_key());
 
 		if let Some(mut awaited_frontier) = awaited_frontier {
-			awaited_frontier.retain(|&(p, c, _, _)| (p != parent && !finalized_candidates.contains(&c)));
+			awaited_frontier.retain(|entry| entry.relay_parent != relay_parent);
 			tx.put_vec(columns::META, &awaited_chunks_key(), awaited_frontier.encode());
 		}
 
-		for block_data_hash in v {
-			if let Some(candidate_hash) = self.block_hash_to_candidate_hash(block_data_hash) {
-				if !finalized_candidates.contains(&candidate_hash) {
-					tx.delete(columns::DATA, block_data_key(&parent, &block_data_hash).as_slice());
-					tx.delete(columns::DATA, &erasure_chunks_key(&parent, &block_data_hash));
-					tx.delete(columns::DATA, &candidate_key(&candidate_hash));
-					tx.delete(columns::META, &block_to_candidate_key(&block_data_hash));
-				}
-			}
+		let candidates = self.get_candidates_with_relay_parent(&relay_parent);
+
+		for candidate in candidates.into_iter().filter(|c| !finalized_candidates.contains(c)) {
+			// we only delete this data for candidates which were not finalized.
+			// we keep all data for the finalized chain forever at the moment.
+			tx.delete(columns::DATA, execution_data_key(&candidate).as_slice());
+			tx.delete(columns::DATA, &erasure_chunks_key(&candidate));
+			tx.delete(columns::DATA, &candidate_key(&candidate));
 		}
 
 		self.inner.write(tx)
 	}
 
-	/// Query block data.
-	pub fn block_data(&self, relay_parent: Hash, block_data_hash: Hash) -> Option<BlockData> {
-		self.query_inner(columns::DATA, &block_data_key(&relay_parent, &block_data_hash))
+	/// Query execution data by relay parent and candidate hash.
+	pub(crate) fn execution_data(&self, candidate_hash: &Hash) -> Option<ExecutionData> {
+		self.query_inner(columns::DATA, &execution_data_key(candidate_hash))
 	}
 
-	/// Query block data by corresponding candidate receipt's hash.
-	pub fn block_data_by_candidate(&self, relay_parent: Hash, candidate_hash: Hash) -> Option<BlockData> {
-		let receipt_key = candidate_key(&candidate_hash);
-
-		self.query_inner(columns::DATA, &receipt_key[..]).and_then(|receipt: CandidateReceipt| {
-			self.block_data(relay_parent, receipt.block_data_hash)
-		})
-	}
-
-	fn block_hash_to_candidate_hash(&self, block_hash: Hash) -> Option<Hash> {
-		self.query_inner(columns::META, &block_to_candidate_key(&block_hash))
+	/// Get candidates which pinned to the environment of the given relay parent.
+	/// Note that this is not necessarily the same as candidates that were included in a direct
+	/// descendent of the given relay-parent.
+	fn get_candidates_with_relay_parent(&self, relay_parent: &Hash) -> Vec<Hash> {
+		let key = candidates_with_relay_parent_key(relay_parent);
+		self.query_inner(columns::DATA, &key[..]).unwrap_or_default()
 	}
 
 	fn query_inner<T: Decode>(&self, column: u32, key: &[u8]) -> Option<T> {
@@ -394,8 +390,27 @@ impl Store {
 #[cfg(test)]
 mod tests {
 	use super::*;
-	use polkadot_erasure_coding as erasure;
-	use polkadot_primitives::parachain::Id as ParaId;
+	use polkadot_erasure_coding::{self as erasure};
+	use polkadot_primitives::parachain::{
+		Id as ParaId, BlockData, AvailableData, PoVBlock, OmittedValidationData,
+	};
+
+	fn available_data(block_data: &[u8]) -> AvailableData {
+		AvailableData {
+			pov_block: PoVBlock {
+				block_data: BlockData(block_data.to_vec()),
+			},
+			omitted_validation: OmittedValidationData {
+				global_validation: Default::default(),
+				local_validation: Default::default(),
+			}
+		}
+	}
+
+	fn execution_data(available: &AvailableData) -> ExecutionData {
+		let AvailableData { pov_block, omitted_validation } = available.clone();
+		ExecutionData { pov_block, omitted_validation }
+	}
 
 	#[test]
 	fn finalization_removes_unneeded() {
@@ -404,8 +419,23 @@ mod tests {
 		let para_id_1 = 5.into();
 		let para_id_2 = 6.into();
 
-		let block_data_1 = BlockData(vec![1, 2, 3]);
-		let block_data_2 = BlockData(vec![4, 5, 6]);
+		let mut candidate_1 = AbridgedCandidateReceipt::default();
+		let mut candidate_2 = AbridgedCandidateReceipt::default();
+
+		candidate_1.parachain_index = para_id_1;
+		candidate_1.commitments.erasure_root = [6; 32].into();
+		candidate_1.relay_parent = relay_parent;
+
+		candidate_2.parachain_index = para_id_2;
+		candidate_2.commitments.erasure_root = [6; 32].into();
+		candidate_2.relay_parent = relay_parent;
+
+
+		let candidate_1_hash = candidate_1.hash();
+		let candidate_2_hash = candidate_2.hash();
+
+		let available_data_1 = available_data(&[1, 2, 3]);
+		let available_data_2 = available_data(&[4, 5, 6]);
 
 		let erasure_chunk_1 = ErasureChunk {
 			chunk: vec![10, 20, 30],
@@ -420,112 +450,59 @@ mod tests {
 		};
 
 		let store = Store::new_in_memory();
-		store.make_available(Data {
-			relay_parent,
-			parachain_id: para_id_1,
-			block_data: block_data_1.clone(),
-		}).unwrap();
+		store.make_available(candidate_1_hash, available_data_1.clone()).unwrap();
 
-		store.make_available(Data {
-			relay_parent,
-			parachain_id: para_id_2,
-			block_data: block_data_2.clone(),
-		}).unwrap();
-
-		let candidate_1 = CandidateReceipt {
-			parachain_index: para_id_1,
-			collator: Default::default(),
-			signature: Default::default(),
-			head_data: Default::default(),
-			parent_head: Default::default(),
-			fees: 0,
-			block_data_hash: block_data_1.hash(),
-			upward_messages: Vec::new(),
-			erasure_root: [6; 32].into(),
-		};
-
-		let candidate_2 = CandidateReceipt {
-			parachain_index: para_id_2,
-			collator: Default::default(),
-			signature: Default::default(),
-			head_data: Default::default(),
-			parent_head: Default::default(),
-			fees: 0,
-			block_data_hash: block_data_2.hash(),
-			upward_messages: Vec::new(),
-			erasure_root: [6; 32].into(),
-		};
+		store.make_available(candidate_2_hash, available_data_2.clone()).unwrap();
 
 		store.add_candidate(&candidate_1).unwrap();
 		store.add_candidate(&candidate_2).unwrap();
 
-		assert!(store.add_erasure_chunks(3, &relay_parent, &candidate_1.hash(), vec![erasure_chunk_1.clone()]).is_ok());
-		assert!(store.add_erasure_chunks(3, &relay_parent, &candidate_2.hash(), vec![erasure_chunk_2.clone()]).is_ok());
+		store.note_candidates_with_relay_parent(&relay_parent, &[candidate_1_hash, candidate_2_hash]).unwrap();
 
-		assert_eq!(store.block_data(relay_parent, block_data_1.hash()).unwrap(), block_data_1);
-		assert_eq!(store.block_data(relay_parent, block_data_2.hash()).unwrap(), block_data_2);
+		assert!(store.add_erasure_chunks(3, &candidate_1_hash, vec![erasure_chunk_1.clone()]).is_ok());
+		assert!(store.add_erasure_chunks(3, &candidate_2_hash, vec![erasure_chunk_2.clone()]).is_ok());
 
-		assert_eq!(store.get_erasure_chunk(&relay_parent, block_data_1.hash(), 1).as_ref(), Some(&erasure_chunk_1));
-		assert_eq!(store.get_erasure_chunk(&relay_parent, block_data_2.hash(), 1), Some(erasure_chunk_2));
+		assert_eq!(store.execution_data(&candidate_1_hash).unwrap(), execution_data(&available_data_1));
+		assert_eq!(store.execution_data(&candidate_2_hash).unwrap(), execution_data(&available_data_2));
 
-		assert_eq!(store.get_candidate(&candidate_1.hash()), Some(candidate_1.clone()));
-		assert_eq!(store.get_candidate(&candidate_2.hash()), Some(candidate_2.clone()));
+		assert_eq!(store.get_erasure_chunk(&candidate_1_hash, 1).as_ref(), Some(&erasure_chunk_1));
+		assert_eq!(store.get_erasure_chunk(&candidate_2_hash, 1), Some(erasure_chunk_2));
 
-		assert_eq!(store.block_data_by_candidate(relay_parent, candidate_1.hash()).unwrap(), block_data_1);
-		assert_eq!(store.block_data_by_candidate(relay_parent, candidate_2.hash()).unwrap(), block_data_2);
+		assert_eq!(store.get_candidate(&candidate_1_hash), Some(candidate_1.clone()));
+		assert_eq!(store.get_candidate(&candidate_2_hash), Some(candidate_2.clone()));
 
-		store.candidates_finalized(relay_parent, [candidate_1.hash()].iter().cloned().collect()).unwrap();
+		store.candidates_finalized(relay_parent, [candidate_1_hash].iter().cloned().collect()).unwrap();
 
-		assert_eq!(store.get_erasure_chunk(&relay_parent, block_data_1.hash(), 1).as_ref(), Some(&erasure_chunk_1));
-		assert!(store.get_erasure_chunk(&relay_parent, block_data_2.hash(), 1).is_none());
+		assert_eq!(store.get_erasure_chunk(&candidate_1_hash, 1).as_ref(), Some(&erasure_chunk_1));
+		assert!(store.get_erasure_chunk(&candidate_2_hash, 1).is_none());
 
-		assert_eq!(store.get_candidate(&candidate_1.hash()), Some(candidate_1));
-		assert_eq!(store.get_candidate(&candidate_2.hash()), None);
+		assert_eq!(store.get_candidate(&candidate_1_hash), Some(candidate_1));
+		assert_eq!(store.get_candidate(&candidate_2_hash), None);
 
-		assert_eq!(store.block_data(relay_parent, block_data_1.hash()).unwrap(), block_data_1);
-		assert!(store.block_data(relay_parent, block_data_2.hash()).is_none());
-	}
-
-	#[test]
-	fn queues_available_by_queue_root() {
-		let relay_parent = [1; 32].into();
-		let para_id = 5.into();
-		let block_data = BlockData(vec![1, 2, 3]);
-
-		let store = Store::new_in_memory();
-		store.make_available(Data {
-			relay_parent,
-			parachain_id: para_id,
-			block_data,
-		}).unwrap();
+		assert_eq!(store.execution_data(&candidate_1_hash).unwrap(), execution_data(&available_data_1));
+		assert!(store.execution_data(&candidate_2_hash).is_none());
 	}
 
 	#[test]
 	fn erasure_coding() {
 		let relay_parent: Hash = [1; 32].into();
 		let para_id: ParaId = 5.into();
-		let block_data = BlockData(vec![42; 8]);
-		let block_data_hash = block_data.hash();
+		let available_data = available_data(&[42; 8]);
 		let n_validators = 5;
 
 		let erasure_chunks = erasure::obtain_chunks(
 			n_validators,
-			&block_data,
+			&available_data,
 		).unwrap();
 
 		let branches = erasure::branches(erasure_chunks.as_ref());
 
-		let candidate = CandidateReceipt {
-			parachain_index: para_id,
-			collator: Default::default(),
-			signature: Default::default(),
-			head_data: Default::default(),
-			parent_head: Default::default(),
-			fees: 0,
-			block_data_hash: block_data.hash(),
-			upward_messages: Vec::new(),
-			erasure_root: [6; 32].into(),
-		};
+		let mut candidate = AbridgedCandidateReceipt::default();
+		candidate.parachain_index = para_id;
+		candidate.commitments.erasure_root = [6; 32].into();
+		candidate.relay_parent = relay_parent;
+
+		let candidate_hash = candidate.hash();
 
 		let chunks: Vec<_> = erasure_chunks
 			.iter()
@@ -541,13 +518,13 @@ mod tests {
 		let store = Store::new_in_memory();
 
 		store.add_candidate(&candidate).unwrap();
-		store.add_erasure_chunks(n_validators as u32, &relay_parent, &candidate.hash(), vec![chunks[0].clone()]).unwrap();
-		assert_eq!(store.get_erasure_chunk(&relay_parent, block_data_hash, 0), Some(chunks[0].clone()));
+		store.add_erasure_chunks(n_validators as u32, &candidate_hash, vec![chunks[0].clone()]).unwrap();
+		assert_eq!(store.get_erasure_chunk(&candidate_hash, 0), Some(chunks[0].clone()));
 
-		assert!(store.block_data(relay_parent, block_data_hash).is_none());
+		assert!(store.execution_data(&candidate_hash).is_none());
 
-		store.add_erasure_chunks(n_validators as u32, &relay_parent, &candidate.hash(), chunks).unwrap();
-		assert_eq!(store.block_data(relay_parent, block_data_hash), Some(block_data));
+		store.add_erasure_chunks(n_validators as u32, &candidate_hash, chunks).unwrap();
+		assert_eq!(store.execution_data(&candidate_hash), Some(execution_data(&available_data)));
 	}
 
 	#[test]
@@ -555,7 +532,7 @@ mod tests {
 		let relay_parent = [42; 32].into();
 		let store = Store::new_in_memory();
 
-		store.add_validator_index_and_n_validators(&relay_parent, 42, 24).unwrap();
+		store.note_validator_index_and_n_validators(&relay_parent, 42, 24).unwrap();
 		assert_eq!(store.get_validator_index_and_n_validators(&relay_parent).unwrap(), (42, 24));
 	}
 
@@ -566,8 +543,8 @@ mod tests {
 
 		let candidates = vec![[1; 32].into(), [2; 32].into(), [3; 32].into()];
 
-		store.add_candidates_in_relay_block(&relay_parent, candidates.clone()).unwrap();
-		assert_eq!(store.get_candidates_in_relay_block(&relay_parent).unwrap(), candidates);
+		store.note_candidates_with_relay_parent(&relay_parent, &candidates).unwrap();
+		assert_eq!(store.get_candidates_with_relay_parent(&relay_parent), candidates);
 	}
 
 	#[test]
@@ -578,25 +555,32 @@ mod tests {
 		let relay_parent = [42; 32].into();
 		let erasure_root_1 = [11; 32].into();
 		let erasure_root_2 = [12; 32].into();
-		let mut receipt_1 = CandidateReceipt::default();
-		let mut receipt_2 = CandidateReceipt::default();
+		let mut receipt_1 = AbridgedCandidateReceipt::default();
+		let mut receipt_2 = AbridgedCandidateReceipt::default();
+
 
 		receipt_1.parachain_index = 1.into();
-		receipt_1.erasure_root = erasure_root_1;
+		receipt_1.commitments.erasure_root = erasure_root_1;
+		receipt_1.relay_parent = relay_parent;
+
 		receipt_2.parachain_index = 2.into();
-		receipt_2.erasure_root = erasure_root_2;
+		receipt_2.commitments.erasure_root = erasure_root_2;
+		receipt_2.relay_parent = relay_parent;
+
+		let receipt_1_hash = receipt_1.hash();
+		let receipt_2_hash = receipt_2.hash();
 
 		let chunk = ErasureChunk {
 			chunk: vec![1, 2, 3],
 			index: validator_index,
 			proof: Vec::new(),
 		};
-		let candidates = vec![receipt_1.hash(), receipt_2.hash()];
+		let candidates = vec![receipt_1_hash, receipt_2_hash];
 		let erasure_roots = vec![erasure_root_1, erasure_root_2];
 
 		let store = Store::new_in_memory();
 
-		store.add_validator_index_and_n_validators(
+		store.note_validator_index_and_n_validators(
 			&relay_parent,
 			validator_index,
 			n_validators
@@ -605,7 +589,7 @@ mod tests {
 		store.add_candidate(&receipt_2).unwrap();
 
 		// We are waiting for chunks from two candidates.
-		store.add_candidates_in_relay_block(&relay_parent, candidates.clone()).unwrap();
+		store.note_candidates_with_relay_parent(&relay_parent, &candidates).unwrap();
 
 		let awaited_frontier = store.awaited_chunks().unwrap();
 		warn!(target: "availability", "awaited {:?}", awaited_frontier);
@@ -613,18 +597,24 @@ mod tests {
 			.clone()
 			.into_iter()
 			.zip(erasure_roots.iter())
-			.map(|(c, e)| (relay_parent, *e, c, validator_index))
+			.map(|(_c, &e)| AwaitedFrontierEntry {
+				relay_parent,
+				erasure_root: e,
+				validator_index,
+			})
 			.collect();
 		assert_eq!(awaited_frontier, expected);
 
 		// We add chunk from one of the candidates.
-		store.add_erasure_chunks(n_validators, &relay_parent, &receipt_1.hash(), vec![chunk]).unwrap();
+		store.add_erasure_chunks(n_validators, &receipt_1_hash, vec![chunk]).unwrap();
 
 		let awaited_frontier = store.awaited_chunks().unwrap();
 		// Now we wait for the other chunk that we haven't received yet.
-		let expected: HashSet<_> = vec![
-			(relay_parent, erasure_roots[1], candidates[1], validator_index)
-		].into_iter().collect();
+		let expected: HashSet<_> = vec![AwaitedFrontierEntry {
+			relay_parent,
+			erasure_root: erasure_roots[1],
+			validator_index,
+		}].into_iter().collect();
 
 		assert_eq!(awaited_frontier, expected);