Initial validator trait. (#14)

* Initial validator trait.

* Add missing docs warning.

* Fix formatting.

* Fix validator output and serialization.

* Get rid of redundant ValidationCode type.

substrate/primitives/src/block.rs

@@ -16,50 +16,23 @@
 
 //! Block and header type definitions.
 
-use bytes;
 use hash::H256;
+use parachain;
 
 /// Hash used to refer to a block hash.
 pub type HeaderHash = H256;
-/// Hash used to refer to proof of block header.
-pub type ProofHash = H256;
-
-/// Unique identifier of a parachain.
-#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy, Serialize, Deserialize)]
-pub struct ParachainId(u64);
-
-impl From<ParachainId> for u64 {
-	fn from(x: ParachainId) -> Self { x.0 }
-}
-
-impl From<u64> for ParachainId {
-	fn from(x: u64) -> Self { ParachainId(x) }
-}
-
-/// A wrapper type for parachain block header raw bytes.
-#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
-pub struct ParachainBlockHeader(#[serde(with="bytes")] pub Vec<u8>);
-
-/// A parachain block proposal.
-#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
-pub struct ParachainProposal {
-	/// The ID of the parachain this is a proposal for.
-	pub parachain: ParachainId,
-	/// Parachain block header bytes.
-	pub header: ParachainBlockHeader,
-	/// Hash of data necessary to prove validity of the header.
-	pub proof_hash: ProofHash,
-}
 
 /// A relay chain block header.
 #[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub struct Header {
 	/// Block parent's hash.
-    pub parent_hash: HeaderHash,
+	#[serde(rename="parentHash")]
+	pub parent_hash: HeaderHash,
 	/// State root after this transition.
-    pub state_root: H256,
+	#[serde(rename="stateRoot")]
+	pub state_root: H256,
 	/// Unix time at which this header was produced.
-    pub timestamp: u64,
+	pub timestamp: u64,
 	/// Block number.
 	pub number: u64,
 }
@@ -71,7 +44,8 @@ pub struct Header {
 #[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub struct Body {
 	/// Parachain proposal blocks.
-    pub para_blocks: Vec<ParachainProposal>,
+	#[serde(rename="paraBlocks")]
+	pub para_blocks: Vec<parachain::Proposal>,
 }
 
 
@@ -88,8 +62,8 @@ mod tests {
 			timestamp: 10,
 			number: 67,
 		}), r#"{
-  "parent_hash": "0x0000000000000000000000000000000000000000000000000000000000000005",
-  "state_root": "0x0000000000000000000000000000000000000000000000000000000000000003",
+  "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000005",
+  "stateRoot": "0x0000000000000000000000000000000000000000000000000000000000000003",
   "timestamp": 10,
   "number": 67
 }"#);
@@ -99,18 +73,18 @@ mod tests {
 	fn test_body_serialization() {
 		assert_eq!(ser::to_string_pretty(&Body {
 			para_blocks: vec![
-				ParachainProposal {
+				parachain::Proposal {
 					parachain: 5.into(),
-					header: ParachainBlockHeader(vec![1, 2, 3, 4]),
+					header: parachain::Header(vec![1, 2, 3, 4]),
 					proof_hash: 5.into(),
 				}
 			],
 		}), r#"{
-  "para_blocks": [
+  "paraBlocks": [
     {
       "parachain": 5,
       "header": "0x01020304",
-      "proof_hash": "0x0000000000000000000000000000000000000000000000000000000000000005"
+      "proofHash": "0x0000000000000000000000000000000000000000000000000000000000000005"
     }
   ]
 }"#);

substrate/primitives/src/lib.rs

@@ -18,8 +18,9 @@
 
 #![warn(missing_docs)]
 
-extern crate serde;
 extern crate rustc_hex;
+extern crate serde;
+extern crate tiny_keccak;
 
 #[macro_use]
 extern crate crunchy;
@@ -41,7 +42,14 @@ extern crate pretty_assertions;
 mod bytes;
 pub mod block;
 pub mod hash;
+pub mod parachain;
 pub mod uint;
+pub mod validator;
 
 /// Alias to 160-bit hash when used in the context of an account address.
 pub type Address = hash::H160;
+
+/// A hash function.
+pub fn hash(data: &[u8]) -> hash::H256 {
+	tiny_keccak::keccak256(data).into()
+}

substrate/primitives/src/parachain.rs

@@ -0,0 +1,100 @@
+// Copyright 2017 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/>.
+
+//! Parachain data types.
+
+use bytes;
+
+/// Unique identifier of a parachain.
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy, Serialize, Deserialize)]
+pub struct Id(u64);
+
+impl From<Id> for u64 {
+	fn from(x: Id) -> Self { x.0 }
+}
+
+impl From<u64> for Id {
+	fn from(x: u64) -> Self { Id(x) }
+}
+
+/// A parachain block proposal.
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct Proposal {
+	/// The ID of the parachain this is a proposal for.
+	pub parachain: Id,
+	/// Parachain block header bytes.
+	pub header: Header,
+	/// Hash of data necessary to prove validity of the header.
+	#[serde(rename="proofHash")]
+	pub proof_hash: ProofHash,
+}
+
+/// Parachain header raw bytes wrapper type.
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct Header(#[serde(with="bytes")] pub Vec<u8>);
+
+/// Hash used to refer to proof of block header.
+pub type ProofHash = ::hash::H256;
+
+/// Raw proof data.
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct RawProof(#[serde(with="bytes")] pub Vec<u8>);
+
+impl RawProof {
+	/// Compute and store the hash of the proof.
+	pub fn into_proof(self) -> Proof {
+		let hash = ::hash(&self.0);
+		Proof(self, hash)
+	}
+}
+
+/// Parachain proof data.
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct Proof(RawProof, ProofHash);
+
+impl Proof {
+	/// Get raw proof data.
+	pub fn raw(&self) -> &RawProof { &self.0 }
+
+	/// Get hash of proof data.
+	pub fn hash(&self) -> &ProofHash { &self.1 }
+
+	/// Decompose the proof back into raw data and hash.
+	pub fn into_inner(self) -> (RawProof, ProofHash) {
+		(self.0, self.1)
+	}
+}
+
+/// Parachain validation code.
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct ValidationCode(#[serde(with="bytes")] pub Vec<u8>);
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use polkadot_serializer as ser;
+
+	#[test]
+	fn test_proof_serialization() {
+		assert_eq!(
+			ser::to_string_pretty(&Proof(RawProof(vec![1,2,3]), 5.into())),
+			r#"[
+  "0x010203",
+  "0x0000000000000000000000000000000000000000000000000000000000000005"
+]"#
+		)
+	}
+}

substrate/primitives/src/validator.rs

@@ -0,0 +1,104 @@
+// Copyright 2017 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/>.
+
+//! Validator primitives.
+
+use bytes;
+
+/// Parachain incoming messages.
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct IngressPosts(#[serde(with="bytes")] pub Vec<u8>);
+
+/// Parachain incoming messages delta.
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct IngressPostsDelta(#[serde(with="bytes")] pub Vec<u8>);
+
+/// Parachain outgoing messages.
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct EgressPosts(#[serde(with="bytes")] pub Vec<u8>);
+
+/// Validity result of particular proof and ingress queue.
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(tag="type", content="data")]
+pub enum ProofValidity {
+	/// The proof is invalid.
+	#[serde(rename="invalid")]
+	Invalid,
+	#[serde(rename="valid")]
+	/// The proof is processed and new egress queue is created.
+	/// Also includes current ingress queue delta.
+	Valid(IngressPostsDelta, EgressPosts),
+}
+
+impl ProofValidity {
+	/// The proof is valid.
+	pub fn is_valid(&self) -> bool {
+		match *self {
+			ProofValidity::Invalid => false,
+			ProofValidity::Valid(..) => true,
+		}
+	}
+}
+
+impl From<Option<(IngressPostsDelta, EgressPosts)>> for ProofValidity {
+	fn from(posts: Option<(IngressPostsDelta, EgressPosts)>) -> Self {
+		match posts {
+			Some((delta, posts)) => ProofValidity::Valid(delta, posts),
+			None => ProofValidity::Invalid,
+		}
+	}
+}
+
+// TODO [ToDr] This shouldn't be here!
+/// Validator logic.
+pub trait Validator {
+	/// Validation error.
+	type Error: ::std::error::Error;
+
+	/// Validates if the provided proof holds given a current ingress queue.
+	///
+	/// In case of success produces egress posts.
+	fn validate(
+		&self,
+		messages: &IngressPosts,
+		proof: &::parachain::Proof,
+		code: &[u8],
+	) -> Result<ProofValidity, Self::Error>;
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use polkadot_serializer as ser;
+
+	#[test]
+	fn test_proof_validity_serialization() {
+		assert_eq!(
+			ser::to_string_pretty(&ProofValidity::Invalid),
+			r#"{
+  "type": "invalid"
+}"#);
+		assert_eq!(
+			ser::to_string_pretty(&ProofValidity::Valid(IngressPostsDelta(vec![1]), EgressPosts(vec![1, 2, 3]))),
+			r#"{
+  "type": "valid",
+  "data": [
+    "0x01",
+    "0x010203"
+  ]
+}"#);
+	}
+}