Refactor primitives (#1383)

* create a v1 primitives module

* Improve guide on availability types

* punctuate

* new parachains runtime uses new primitives

* tests of new runtime now use new primitives

* add ErasureChunk to guide

* export erasure chunk from v1 primitives

* subsystem crate uses v1 primitives

* node-primitives uses new v1 primitives

* port overseer to new primitives

* new-proposer uses v1 primitives (no ParachainHost anymore)

* fix no-std compilation for primitives

* service-new uses v1 primitives

* network-bridge uses new primitives

* statement distribution uses v1 primitives

* PoV distribution uses v1 primitives; add PoV::hash fn

* move parachain to v0

* remove inclusion_inherent module and place into v1

* remove everything from primitives crate root

* remove some unused old types from v0 primitives

* point everything else at primitives::v0

* squanch some warns up

* add RuntimeDebug import to no-std as well

* port over statement-table and validation

* fix final errors in validation and node-primitives

* add dummy Ord impl to committed candidate receipt

* guide: update CandidateValidationMessage

* add primitive for validationoutputs

* expand CandidateValidationMessage further

* bikeshed

* add some impls to omitted-validation-data and available-data

* expand CandidateValidationMessage

* make erasure-coding generic over v1/v0

* update usages of erasure-coding

* implement commitments.hash()

* use Arc<Pov> for CandidateValidation

* improve new erasure-coding method names

* fix up candidate backing

* update docs a bit

* fix most tests and add short-circuiting to make_pov_available

* fix remainder of candidate backing tests

* squanching warns

* squanch it up

* some fallout

* overseer fallout

* free from polkadot-test-service hell

polkadot/statement-table/src/generic.rs

@@ -28,7 +28,7 @@ use std::collections::hash_map::{HashMap, Entry};
 use std::hash::Hash;
 use std::fmt::Debug;
 
-use primitives::parachain::{ValidityAttestation as PrimitiveValidityAttestation, ValidatorSignature};
+use primitives::v1::{ValidityAttestation as PrimitiveValidityAttestation, ValidatorSignature};
 
 use codec::{Encode, Decode};
 

polkadot/statement-table/src/lib.rs

@@ -16,75 +16,87 @@
 
 pub mod generic;
 
-pub use generic::Table;
+pub use generic::{Table, Context};
 
-use primitives::parachain::{
-	Id, AbridgedCandidateReceipt, CompactStatement as PrimitiveStatement, ValidatorSignature, ValidatorIndex,
-};
-use primitives::Hash;
+/// Concrete instantiations suitable for v0 primitives.
+pub mod v0 {
+	use crate::generic;
+	use primitives::v0::{
+		Hash,
+		Id, AbridgedCandidateReceipt, CompactStatement as PrimitiveStatement, ValidatorSignature, ValidatorIndex,
+	};
 
-/// Statements about candidates on the network.
-pub type Statement = generic::Statement<AbridgedCandidateReceipt, Hash>;
+	/// Statements about candidates on the network.
+	pub type Statement = generic::Statement<AbridgedCandidateReceipt, Hash>;
 
-/// Signed statements about candidates.
-pub type SignedStatement = generic::SignedStatement<
-	AbridgedCandidateReceipt,
-	Hash,
-	ValidatorIndex,
-	ValidatorSignature,
->;
+	/// Signed statements about candidates.
+	pub type SignedStatement = generic::SignedStatement<
+		AbridgedCandidateReceipt,
+		Hash,
+		ValidatorIndex,
+		ValidatorSignature,
+	>;
 
-/// Kinds of misbehavior, along with proof.
-pub type Misbehavior = generic::Misbehavior<
-	AbridgedCandidateReceipt,
-	Hash,
-	ValidatorIndex,
-	ValidatorSignature,
->;
+	/// Kinds of misbehavior, along with proof.
+	pub type Misbehavior = generic::Misbehavior<
+		AbridgedCandidateReceipt,
+		Hash,
+		ValidatorIndex,
+		ValidatorSignature,
+	>;
 
-/// A summary of import of a statement.
-pub type Summary = generic::Summary<Hash, Id>;
+	/// A summary of import of a statement.
+	pub type Summary = generic::Summary<Hash, Id>;
 
-/// Context necessary to construct a table.
-pub trait Context {
-	/// Whether a authority is a member of a group.
-	/// Members are meant to submit candidates and vote on validity.
-	fn is_member_of(&self, authority: ValidatorIndex, group: &Id) -> bool;
-
-	/// requisite number of votes for validity from a group.
-	fn requisite_votes(&self, group: &Id) -> usize;
-}
-
-impl<C: Context> generic::Context for C {
-	type AuthorityId = ValidatorIndex;
-	type Digest = Hash;
-	type GroupId = Id;
-	type Signature = ValidatorSignature;
-	type Candidate = AbridgedCandidateReceipt;
-
-	fn candidate_digest(candidate: &AbridgedCandidateReceipt) -> Hash {
-		candidate.hash()
-	}
-
-	fn candidate_group(candidate: &AbridgedCandidateReceipt) -> Id {
-		candidate.parachain_index.clone()
-	}
-
-	fn is_member_of(&self, authority: &Self::AuthorityId, group: &Id) -> bool {
-		Context::is_member_of(self, *authority, group)
-	}
-
-	fn requisite_votes(&self, group: &Id) -> usize {
-		Context::requisite_votes(self, group)
-	}
-}
-
-impl<'a> From<&'a Statement> for PrimitiveStatement {
-	fn from(s: &'a Statement) -> PrimitiveStatement {
-		match *s {
-			generic::Statement::Valid(s) => PrimitiveStatement::Valid(s),
-			generic::Statement::Invalid(s) => PrimitiveStatement::Invalid(s),
-			generic::Statement::Candidate(ref s) => PrimitiveStatement::Candidate(s.hash()),
+	impl<'a> From<&'a Statement> for PrimitiveStatement {
+		fn from(s: &'a Statement) -> PrimitiveStatement {
+			match *s {
+				generic::Statement::Valid(s) => PrimitiveStatement::Valid(s),
+				generic::Statement::Invalid(s) => PrimitiveStatement::Invalid(s),
+				generic::Statement::Candidate(ref s) => PrimitiveStatement::Candidate(s.hash()),
+			}
+		}
+	}
+}
+
+/// Concrete instantiations suitable for v1 primitives.
+pub mod v1 {
+	use crate::generic;
+	use primitives::v1::{
+		Hash,
+		Id, CommittedCandidateReceipt, CompactStatement as PrimitiveStatement,
+		ValidatorSignature, ValidatorIndex,
+	};
+
+	/// Statements about candidates on the network.
+	pub type Statement = generic::Statement<CommittedCandidateReceipt, Hash>;
+
+	/// Signed statements about candidates.
+	pub type SignedStatement = generic::SignedStatement<
+		CommittedCandidateReceipt,
+		Hash,
+		ValidatorIndex,
+		ValidatorSignature,
+	>;
+
+	/// Kinds of misbehavior, along with proof.
+	pub type Misbehavior = generic::Misbehavior<
+		CommittedCandidateReceipt,
+		Hash,
+		ValidatorIndex,
+		ValidatorSignature,
+	>;
+
+	/// A summary of import of a statement.
+	pub type Summary = generic::Summary<Hash, Id>;
+
+	impl<'a> From<&'a Statement> for PrimitiveStatement {
+		fn from(s: &'a Statement) -> PrimitiveStatement {
+			match *s {
+				generic::Statement::Valid(s) => PrimitiveStatement::Valid(s),
+				generic::Statement::Invalid(s) => PrimitiveStatement::Invalid(s),
+				generic::Statement::Candidate(ref s) => PrimitiveStatement::Candidate(s.hash()),
+			}
 		}
 	}
 }