Fix warning and directory restructure.

substrate/polkadot/primitives/src/block.rs

@@ -0,0 +1,197 @@
+// 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/>.
+
+//! Block and header type definitions.
+
+#[cfg(feature = "std")]
+use primitives::bytes;
+use primitives::H256;
+use rstd::vec::Vec;
+use codec::Slicable;
+use transaction::UncheckedTransaction;
+
+/// Used to refer to a block number.
+pub type Number = u64;
+
+/// Hash used to refer to a block hash.
+pub type HeaderHash = H256;
+
+/// Hash used to refer to a transaction hash.
+pub type TransactionHash = H256;
+
+/// Execution log (event)
+#[derive(PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+pub struct Log(#[cfg_attr(feature = "std", serde(with="bytes"))] pub Vec<u8>);
+
+impl Slicable for Log {
+	fn from_slice(value: &mut &[u8]) -> Option<Self> {
+		Vec::<u8>::from_slice(value).map(Log)
+	}
+
+	fn as_slice_then<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
+		self.0.as_slice_then(f)
+	}
+}
+
+impl ::codec::NonTrivialSlicable for Log { }
+
+/// The digest of a block, useful for light-clients.
+#[derive(Clone, Default, PartialEq, Eq)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+pub struct Digest {
+	/// All logs that have happened in the block.
+	pub logs: Vec<Log>,
+}
+
+impl Slicable for Digest {
+	fn from_slice(value: &mut &[u8]) -> Option<Self> {
+		Vec::<Log>::from_slice(value).map(|logs| Digest { logs })
+	}
+
+	fn as_slice_then<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
+		self.logs.as_slice_then(f)
+	}
+}
+
+/// The block "body": A bunch of transactions.
+pub type Body = Vec<UncheckedTransaction>;
+
+/// A Polkadot relay chain block.
+#[derive(PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+pub struct Block {
+	/// The block header.
+	pub header: Header,
+	/// All relay-chain transactions.
+	pub transactions: Body,
+}
+
+impl Slicable for Block {
+	fn from_slice(value: &mut &[u8]) -> Option<Self> {
+		Some(Block {
+			header: try_opt!(Slicable::from_slice(value)),
+			transactions: try_opt!(Slicable::from_slice(value)),
+		})
+	}
+
+	fn to_vec(&self) -> Vec<u8> {
+		let mut v = Vec::new();
+
+		v.extend(self.header.to_vec());
+		v.extend(self.transactions.to_vec());
+
+		v
+	}
+
+	fn as_slice_then<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
+		f(self.to_vec().as_slice())
+	}
+}
+
+/// A relay chain block header.
+///
+/// https://github.com/w3f/polkadot-spec/blob/master/spec.md#header
+#[derive(PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+#[cfg_attr(feature = "std", serde(rename_all = "camelCase"))]
+#[cfg_attr(feature = "std", serde(deny_unknown_fields))]
+pub struct Header {
+	/// Block parent's hash.
+	pub parent_hash: HeaderHash,
+	/// Block number.
+	pub number: Number,
+	/// State root after this transition.
+	pub state_root: H256,
+	/// The root of the trie that represents this block's transactions, indexed by a 32-byte integer.
+	pub transaction_root: H256,
+	/// The digest of activity on the block.
+	pub digest: Digest,
+}
+
+impl Header {
+	/// Create a new instance with default fields except `number`, which is given as an argument.
+	pub fn from_block_number(number: Number) -> Self {
+		Header {
+			parent_hash: Default::default(),
+			number,
+			state_root: Default::default(),
+			transaction_root: Default::default(),
+			digest: Default::default(),
+		}
+	}
+}
+
+impl Slicable for Header {
+	fn from_slice(value: &mut &[u8]) -> Option<Self> {
+		Some(Header {
+			parent_hash: try_opt!(Slicable::from_slice(value)),
+			number: try_opt!(Slicable::from_slice(value)),
+			state_root: try_opt!(Slicable::from_slice(value)),
+			transaction_root: try_opt!(Slicable::from_slice(value)),
+			digest: try_opt!(Slicable::from_slice(value)),
+		})
+	}
+
+	fn to_vec(&self) -> Vec<u8> {
+		let mut v = Vec::new();
+
+		self.parent_hash.as_slice_then(|s| v.extend(s));
+		self.number.as_slice_then(|s| v.extend(s));
+		self.state_root.as_slice_then(|s| v.extend(s));
+		self.transaction_root.as_slice_then(|s| v.extend(s));
+		self.digest.as_slice_then(|s| v.extend(s));
+
+		v
+	}
+
+	fn as_slice_then<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
+		f(self.to_vec().as_slice())
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use codec::Slicable;
+	use substrate_serializer as ser;
+
+	#[test]
+	fn test_header_serialization() {
+		let header = Header {
+			parent_hash: 5.into(),
+			number: 67,
+			state_root: 3.into(),
+			transaction_root: 6.into(),
+			digest: Digest { logs: vec![Log(vec![1])] },
+		};
+
+		assert_eq!(ser::to_string_pretty(&header), r#"{
+  "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000005",
+  "number": 67,
+  "stateRoot": "0x0000000000000000000000000000000000000000000000000000000000000003",
+  "transactionRoot": "0x0000000000000000000000000000000000000000000000000000000000000006",
+  "digest": {
+    "logs": [
+      "0x01"
+    ]
+  }
+}"#);
+
+		let v = header.to_vec();
+		assert_eq!(Header::from_slice(&mut &v[..]).unwrap(), header);
+	}
+}

substrate/polkadot/primitives/src/lib.rs

@@ -0,0 +1,78 @@
+// 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/>.
+
+//! Shareable Polkadot types.
+
+#![warn(missing_docs)]
+
+#![cfg_attr(not(feature = "std"), no_std)]
+#![cfg_attr(not(feature = "std"), feature(alloc))]
+
+
+#[cfg(feature = "std")]
+#[macro_use]
+extern crate serde_derive;
+#[cfg(feature = "std")]
+extern crate serde;
+
+extern crate substrate_runtime_std as rstd;
+extern crate substrate_codec as codec;
+extern crate substrate_primitives as primitives;
+#[cfg(test)]
+extern crate substrate_serializer;
+
+macro_rules! try_opt {
+	($e: expr) => {
+		match $e {
+			Some(x) => x,
+			None => return None,
+		}
+	}
+}
+
+pub mod parachain;
+pub mod validator;
+pub mod block;
+pub mod transaction;
+
+pub use self::block::{Header, Block, Log, Digest};
+pub use self::block::Number as BlockNumber;
+pub use self::transaction::{Transaction, UncheckedTransaction, Function, Proposal};
+
+/// Virtual account ID that represents the idea of a dispatch/statement being signed by everybody
+/// (who matters). Essentially this means that a majority of validators have decided it is
+/// "correct".
+pub const EVERYBODY: AccountId = [255u8; 32];
+
+/// Alias to Ed25519 pubkey that identifies an account on the relay chain. This will almost
+/// certainly continue to be the same as the substrate's `AuthorityId`.
+pub type AccountId = primitives::AuthorityId;
+
+/// The Ed25519 pub key of an session that belongs to an authority of the relay chain. This is
+/// exactly equivalent to what the substrate calls an "authority".
+pub type SessionKey = primitives::AuthorityId;
+
+/// Indentifier for a chain.
+pub type ChainID = u64;
+
+/// Index of a transaction in the relay chain.
+pub type TxOrder = u64;
+
+/// A hash of some data used by the relay chain.
+pub type Hash = primitives::H256;
+
+/// Alias to 520-bit hash when used in the context of a signature on the relay chain.
+pub type Signature = primitives::hash::H512;

substrate/polkadot/primitives/src/parachain.rs

@@ -0,0 +1,173 @@
+// 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.
+
+#[cfg(feature = "std")]
+use primitives::bytes;
+use primitives;
+use rstd::vec::Vec;
+
+/// Unique identifier of a parachain.
+#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+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) }
+}
+
+impl ::codec::Slicable for Id {
+	fn from_slice(value: &mut &[u8]) -> Option<Self> {
+		u64::from_slice(value).map(Id)
+	}
+
+	fn as_slice_then<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
+		self.0.as_slice_then(f)
+	}
+}
+
+/// Candidate parachain block.
+///
+/// https://github.com/w3f/polkadot-spec/blob/master/spec.md#candidate-para-chain-block
+#[derive(PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+#[cfg_attr(feature = "std", serde(rename_all = "camelCase"))]
+#[cfg_attr(feature = "std", serde(deny_unknown_fields))]
+pub struct Candidate {
+	/// The ID of the parachain this is a proposal for.
+	pub parachain_index: Id,
+	/// Collator's signature
+	pub collator_signature: ::Signature,
+	/// Unprocessed ingress queue.
+	///
+	/// Ordered by parachain ID and block number.
+	pub unprocessed_ingress: ConsolidatedIngress,
+	/// Block data
+	pub block: BlockData,
+}
+
+/// Candidate receipt type.
+#[derive(PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "std", derive(Debug, Serialize, Deserialize))]
+#[cfg_attr(feature = "std", serde(rename_all = "camelCase"))]
+#[cfg_attr(feature = "std", serde(deny_unknown_fields))]
+pub struct CandidateReceipt {
+	/// The ID of the parachain this is a candidate for.
+	pub parachain_index: Id,
+	/// The collator's relay-chain account ID
+	pub collator: ::AccountId,
+	/// The head-data
+	pub head_data: HeadData,
+	/// Balance uploads to the relay chain.
+	pub balance_uploads: Vec<(::AccountId, u64)>,
+	/// Egress queue roots.
+	pub egress_queue_roots: Vec<(Id, primitives::H256)>,
+	/// Fees paid from the chain to the relay chain validators
+	pub fees: u64,
+}
+
+/// Parachain ingress queue message.
+#[derive(PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+pub struct Message(#[cfg_attr(feature = "std", serde(with="bytes"))] pub Vec<u8>);
+
+/// Consolidated ingress queue data.
+///
+/// This is just an ordered vector of other parachains' egress queues,
+/// obtained according to the routing rules.
+#[derive(Default, PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+pub struct ConsolidatedIngress(pub Vec<(Id, Vec<Message>)>);
+
+/// Parachain block data.
+///
+/// contains everything required to validate para-block, may contain block and witness data
+#[derive(PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+pub struct BlockData(#[cfg_attr(feature = "std", serde(with="bytes"))] pub Vec<u8>);
+
+/// Parachain header raw bytes wrapper type.
+#[derive(PartialEq, Eq)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+pub struct Header(#[cfg_attr(feature = "std", serde(with="bytes"))] pub Vec<u8>);
+
+/// Parachain head data included in the chain.
+#[derive(PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+pub struct HeadData(#[cfg_attr(feature = "std", serde(with="bytes"))] pub Vec<u8>);
+
+/// Parachain validation code.
+#[derive(PartialEq, Eq)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+pub struct ValidationCode(#[cfg_attr(feature = "std", serde(with="bytes"))] pub Vec<u8>);
+
+/// Activitiy bit field
+#[derive(PartialEq, Eq, Clone, Default)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+pub struct Activity(#[cfg_attr(feature = "std", serde(with="bytes"))] pub Vec<u8>);
+
+impl ::codec::Slicable for Activity {
+	fn from_slice(value: &mut &[u8]) -> Option<Self> {
+		Vec::<u8>::from_slice(value).map(Activity)
+	}
+
+	fn as_slice_then<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
+		self.0.as_slice_then(f)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use substrate_serializer as ser;
+
+	#[test]
+	fn test_candidate() {
+		assert_eq!(ser::to_string_pretty(&Candidate {
+			parachain_index: 5.into(),
+			collator_signature: 10.into(),
+			unprocessed_ingress: ConsolidatedIngress(vec![
+				(Id(1), vec![Message(vec![2])]),
+				(Id(2), vec![Message(vec![2]), Message(vec![3])]),
+			]),
+			block: BlockData(vec![1, 2, 3]),
+    }), r#"{
+  "parachainIndex": 5,
+  "collatorSignature": "0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000a",
+  "unprocessedIngress": [
+    [
+      1,
+      [
+        "0x02"
+      ]
+    ],
+    [
+      2,
+      [
+        "0x02",
+        "0x03"
+      ]
+    ]
+  ],
+  "block": "0x010203"
+}"#);
+	}
+}

substrate/polkadot/primitives/src/transaction.rs

@@ -0,0 +1,403 @@
+// 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/>.
+
+//! Transaction type.
+
+use rstd::vec::Vec;
+use codec::Slicable;
+
+#[cfg(feature = "std")]
+use std::fmt;
+
+use block::Number as BlockNumber;
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+#[repr(u8)]
+enum InternalFunctionId {
+	/// Set the system's code.
+	SystemSetCode = 0x00,
+
+	/// Set the session length.
+	SessionSetLength = 0x10,
+	/// Force a new session.
+	SessionForceNewSession = 0x11,
+
+	/// Set the number of sessions per era.
+	StakingSetSessionsPerEra = 0x20,
+	/// Set the minimum bonding duration for staking.
+	StakingSetBondingDuration = 0x21,
+	/// Set the validator count for staking.
+	StakingSetValidatorCount = 0x22,
+	/// Force a new staking era.
+	StakingForceNewEra = 0x23,
+
+	/// Set the per-mille of validator approval required for governance changes.
+	GovernanceSetApprovalPpmRequired = 0x30,
+
+}
+
+impl InternalFunctionId {
+	/// Derive `Some` value from a `u8`, or `None` if it's invalid.
+	fn from_u8(value: u8) -> Option<InternalFunctionId> {
+		let functions = [
+			InternalFunctionId::SystemSetCode,
+			InternalFunctionId::SessionSetLength,
+			InternalFunctionId::SessionForceNewSession,
+			InternalFunctionId::StakingSetSessionsPerEra,
+			InternalFunctionId::StakingSetBondingDuration,
+			InternalFunctionId::StakingSetValidatorCount,
+			InternalFunctionId::StakingForceNewEra,
+			InternalFunctionId::GovernanceSetApprovalPpmRequired,
+		];
+		functions.iter().map(|&f| f).find(|&f| value == f as u8)
+	}
+}
+
+/// Internal functions that can be dispatched to.
+#[derive(Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+pub enum Proposal {
+	/// Set the system's code.
+	SystemSetCode(Vec<u8>),
+	/// Set the session length.
+	SessionSetLength(BlockNumber),
+	/// Force a new session.
+	SessionForceNewSession,
+	/// Set the number of sessions per era.
+	StakingSetSessionsPerEra(BlockNumber),
+	/// Set the minimum bonding duration for staking.
+	StakingSetBondingDuration(BlockNumber),
+	/// Set the validator count for staking.
+	StakingSetValidatorCount(u32),
+	/// Force a new staking era.
+	StakingForceNewEra,
+	/// Set the per-mille of validator approval required for governance changes.
+	GovernanceSetApprovalPpmRequired(u32),
+
+}
+
+impl Slicable for Proposal {
+	fn from_slice(value: &mut &[u8]) -> Option<Self> {
+		let id = try_opt!(u8::from_slice(value).and_then(InternalFunctionId::from_u8));
+		let function = match id {
+			InternalFunctionId::SystemSetCode =>
+				Proposal::SystemSetCode(try_opt!(Slicable::from_slice(value))),
+			InternalFunctionId::SessionSetLength =>
+				Proposal::SessionSetLength(try_opt!(Slicable::from_slice(value))),
+			InternalFunctionId::SessionForceNewSession => Proposal::SessionForceNewSession,
+			InternalFunctionId::StakingSetSessionsPerEra =>
+				Proposal::StakingSetSessionsPerEra(try_opt!(Slicable::from_slice(value))),
+			InternalFunctionId::StakingSetBondingDuration =>
+				Proposal::StakingSetBondingDuration(try_opt!(Slicable::from_slice(value))),
+			InternalFunctionId::StakingSetValidatorCount =>
+				Proposal::StakingSetValidatorCount(try_opt!(Slicable::from_slice(value))),
+			InternalFunctionId::StakingForceNewEra => Proposal::StakingForceNewEra,
+			InternalFunctionId::GovernanceSetApprovalPpmRequired =>
+				Proposal::GovernanceSetApprovalPpmRequired(try_opt!(Slicable::from_slice(value))),
+		};
+
+		Some(function)
+	}
+
+	fn to_vec(&self) -> Vec<u8> {
+		let mut v = Vec::new();
+		match *self {
+			Proposal::SystemSetCode(ref data) => {
+				(InternalFunctionId::SystemSetCode as u8).as_slice_then(|s| v.extend(s));
+				data.as_slice_then(|s| v.extend(s));
+			}
+			Proposal::SessionSetLength(ref data) => {
+				(InternalFunctionId::SessionSetLength as u8).as_slice_then(|s| v.extend(s));
+				data.as_slice_then(|s| v.extend(s));
+			}
+			Proposal::SessionForceNewSession => {
+				(InternalFunctionId::SessionForceNewSession as u8).as_slice_then(|s| v.extend(s));
+			}
+			Proposal::StakingSetSessionsPerEra(ref data) => {
+				(InternalFunctionId::StakingSetSessionsPerEra as u8).as_slice_then(|s| v.extend(s));
+				data.as_slice_then(|s| v.extend(s));
+			}
+			Proposal::StakingSetBondingDuration(ref data) => {
+				(InternalFunctionId::StakingSetBondingDuration as u8).as_slice_then(|s| v.extend(s));
+				data.as_slice_then(|s| v.extend(s));
+			}
+			Proposal::StakingSetValidatorCount(ref data) => {
+				(InternalFunctionId::StakingSetValidatorCount as u8).as_slice_then(|s| v.extend(s));
+				data.as_slice_then(|s| v.extend(s));
+			}
+			Proposal::StakingForceNewEra => {
+				(InternalFunctionId::StakingForceNewEra as u8).as_slice_then(|s| v.extend(s));
+			}
+			Proposal::GovernanceSetApprovalPpmRequired(ref data) => {
+				(InternalFunctionId::GovernanceSetApprovalPpmRequired as u8).as_slice_then(|s| v.extend(s));
+				data.as_slice_then(|s| v.extend(s));
+			}
+		}
+
+		v
+	}
+
+	fn as_slice_then<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
+		f(self.to_vec().as_slice())
+	}
+}
+
+
+/// Public functions that can be dispatched to.
+#[derive(Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+#[repr(u8)]
+enum FunctionId {
+	/// Set the timestamp.
+	TimestampSet = 0x00,
+	/// Set temporary session key as a validator.
+	SessionSetKey = 0x10,
+	/// Staking subsystem: begin staking.
+	StakingStake = 0x20,
+	/// Staking subsystem: stop staking.
+	StakingUnstake = 0x21,
+	/// Staking subsystem: transfer stake.
+	StakingTransfer = 0x22,
+	/// Make a proposal for the governance system.
+	GovernancePropose = 0x30,
+	/// Approve a proposal for the governance system.
+	GovernanceApprove = 0x31,
+}
+
+impl FunctionId {
+	/// Derive `Some` value from a `u8`, or `None` if it's invalid.
+	fn from_u8(value: u8) -> Option<FunctionId> {
+		use self::*;
+		let functions = [FunctionId::StakingStake, FunctionId::StakingUnstake,
+			FunctionId::StakingTransfer, FunctionId::SessionSetKey, FunctionId::TimestampSet,
+			FunctionId::GovernancePropose, FunctionId::GovernanceApprove];
+		functions.iter().map(|&f| f).find(|&f| value == f as u8)
+	}
+}
+
+/// Functions on the runtime.
+#[derive(Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+pub enum Function {
+	/// Set the timestamp.
+	TimestampSet(u64),
+	/// Set temporary session key as a validator.
+	SessionSetKey(::SessionKey),
+	/// Staking subsystem: begin staking.
+	StakingStake,
+	/// Staking subsystem: stop staking.
+	StakingUnstake,
+	/// Staking subsystem: transfer stake.
+	StakingTransfer(::AccountId, u64),
+	/// Make a proposal for the governance system.
+	GovernancePropose(Proposal),
+	/// Approve a proposal for the governance system.
+	GovernanceApprove(BlockNumber),
+}
+
+impl Slicable for Function {
+	fn from_slice(value: &mut &[u8]) -> Option<Self> {
+		let id = try_opt!(u8::from_slice(value).and_then(FunctionId::from_u8));
+		Some(match id {
+			FunctionId::TimestampSet =>
+				Function::TimestampSet(try_opt!(Slicable::from_slice(value))),
+			FunctionId::SessionSetKey =>
+				Function::SessionSetKey(try_opt!(Slicable::from_slice(value))),
+			FunctionId::StakingStake => Function::StakingStake,
+			FunctionId::StakingUnstake => Function::StakingUnstake,
+			FunctionId::StakingTransfer => {
+				let to  = try_opt!(Slicable::from_slice(value));
+				let amount = try_opt!(Slicable::from_slice(value));
+
+				Function::StakingTransfer(to, amount)
+			}
+			FunctionId::GovernancePropose =>
+				Function::GovernancePropose(try_opt!(Slicable::from_slice(value))),
+			FunctionId::GovernanceApprove =>
+				Function::GovernanceApprove(try_opt!(Slicable::from_slice(value))),
+		})
+	}
+
+	fn to_vec(&self) -> Vec<u8> {
+		let mut v = Vec::new();
+		match *self {
+			Function::TimestampSet(ref data) => {
+				(FunctionId::TimestampSet as u8).as_slice_then(|s| v.extend(s));
+				data.as_slice_then(|s| v.extend(s));
+			}
+			Function::SessionSetKey(ref data) => {
+				(FunctionId::SessionSetKey as u8).as_slice_then(|s| v.extend(s));
+				data.as_slice_then(|s| v.extend(s));
+			}
+			Function::StakingStake => {
+				(FunctionId::StakingStake as u8).as_slice_then(|s| v.extend(s));
+			}
+			Function::StakingUnstake => {
+				(FunctionId::StakingUnstake as u8).as_slice_then(|s| v.extend(s));
+			}
+			Function::StakingTransfer(ref to, ref amount) => {
+				(FunctionId::StakingTransfer as u8).as_slice_then(|s| v.extend(s));
+				to.as_slice_then(|s| v.extend(s));
+				amount.as_slice_then(|s| v.extend(s));
+			}
+			Function::GovernancePropose(ref data) => {
+				(FunctionId::GovernancePropose as u8).as_slice_then(|s| v.extend(s));
+				data.as_slice_then(|s| v.extend(s));
+			}
+			Function::GovernanceApprove(ref data) => {
+				(FunctionId::GovernanceApprove as u8).as_slice_then(|s| v.extend(s));
+				data.as_slice_then(|s| v.extend(s));
+			}
+		}
+
+		v
+	}
+
+	fn as_slice_then<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
+		f(self.to_vec().as_slice())
+	}
+}
+
+/// A vetted and verified transaction from the external world.
+#[derive(PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+pub struct Transaction {
+	/// Who signed it (note this is not a signature).
+	pub signed: super::AccountId,
+	/// The number of transactions have come before from the same signer.
+	pub nonce: super::TxOrder,
+	/// The function that should be called.
+	pub function: Function,
+}
+
+impl Slicable for Transaction {
+	fn from_slice(value: &mut &[u8]) -> Option<Self> {
+		Some(Transaction {
+			signed: try_opt!(Slicable::from_slice(value)),
+			nonce: try_opt!(Slicable::from_slice(value)),
+			function: try_opt!(Slicable::from_slice(value)),
+		})
+	}
+
+	fn to_vec(&self) -> Vec<u8> {
+		let mut v = Vec::new();
+
+		self.signed.as_slice_then(|s| v.extend(s));
+		self.nonce.as_slice_then(|s| v.extend(s));
+		self.function.as_slice_then(|s| v.extend(s));
+
+		v
+	}
+
+	fn as_slice_then<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
+		f(self.to_vec().as_slice())
+	}
+}
+
+impl ::codec::NonTrivialSlicable for Transaction {}
+
+/// A transactions right from the external world. Unchecked.
+#[derive(Eq, Clone)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
+pub struct UncheckedTransaction {
+	/// The actual transaction information.
+	pub transaction: Transaction,
+	/// The signature; should be an Ed25519 signature applied to the serialised `transaction` field.
+	pub signature: super::Signature,
+}
+
+impl Slicable for UncheckedTransaction {
+	fn from_slice(value: &mut &[u8]) -> Option<Self> {
+		// This is a little more complicated than usua since the binary format must be compatible
+		// with substrate's generic `Vec<u8>` type. Basically this just means accepting that there
+		// will be a prefix of u32, which has the total number of bytes following (we don't need
+		// to use this).
+		let _length_do_not_remove_me_see_above: u32 = try_opt!(Slicable::from_slice(value));
+
+		Some(UncheckedTransaction {
+			transaction: try_opt!(Slicable::from_slice(value)),
+			signature: try_opt!(Slicable::from_slice(value)),
+		})
+	}
+
+	fn to_vec(&self) -> Vec<u8> {
+		let mut v = Vec::new();
+
+		// need to prefix with the total length as u32 to ensure it's binary comptible with
+		// Vec<u8>. we'll make room for it here, then overwrite once we know the length.
+		v.extend(&[0u8; 4]);
+
+		self.transaction.signed.as_slice_then(|s| v.extend(s));
+		self.transaction.nonce.as_slice_then(|s| v.extend(s));
+		self.transaction.function.as_slice_then(|s| v.extend(s));
+		self.signature.as_slice_then(|s| v.extend(s));
+
+		let length = (v.len() - 4) as u32;
+		length.as_slice_then(|s| v[0..4].copy_from_slice(s));
+
+		v
+	}
+
+	fn as_slice_then<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
+		f(self.to_vec().as_slice())
+	}
+}
+
+impl ::codec::NonTrivialSlicable for UncheckedTransaction {}
+
+impl PartialEq for UncheckedTransaction {
+	fn eq(&self, other: &Self) -> bool {
+		self.signature.iter().eq(other.signature.iter()) && self.transaction == other.transaction
+	}
+}
+
+#[cfg(feature = "std")]
+impl fmt::Debug for UncheckedTransaction {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		write!(f, "UncheckedTransaction({:?})", self.transaction)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use primitives;
+	use ::codec::Slicable;
+	use primitives::hexdisplay::HexDisplay;
+
+	#[test]
+	fn serialize_unchecked() {
+		let tx = UncheckedTransaction {
+			transaction: Transaction {
+				signed: [1; 32],
+				nonce: 999u64,
+				function: Function::TimestampSet(135135),
+			},
+			signature: primitives::hash::H512([0; 64]),
+		};
+		// 71000000
+		// 0101010101010101010101010101010101010101010101010101010101010101
+		// e703000000000000
+		// 00
+		// df0f0200
+		// 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
+
+		let v = Slicable::to_vec(&tx);
+		println!("{}", HexDisplay::from(&v));
+		assert_eq!(UncheckedTransaction::from_slice(&mut &v[..]).unwrap(), tx);
+	}
+}

substrate/polkadot/primitives/src/validator.rs

@@ -0,0 +1,76 @@
+// 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.
+
+#[cfg(feature = "std")]
+use primitives::bytes;
+use rstd::vec::Vec;
+use parachain;
+
+/// Parachain outgoing message.
+#[derive(PartialEq, Eq)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+pub struct EgressPost(#[cfg_attr(feature = "std", serde(with="bytes"))] pub Vec<u8>);
+
+/// Balance upload.
+#[derive(PartialEq, Eq)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+pub struct BalanceUpload(#[cfg_attr(feature = "std", serde(with="bytes"))] pub Vec<u8>);
+
+/// Balance download.
+#[derive(PartialEq, Eq)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+pub struct BalanceDownload(#[cfg_attr(feature = "std", serde(with="bytes"))] pub Vec<u8>);
+
+/// The result of parachain validation.
+#[derive(PartialEq, Eq)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+#[cfg_attr(feature = "std", serde(rename_all = "camelCase"))]
+#[cfg_attr(feature = "std", serde(deny_unknown_fields))]
+pub struct ValidationResult {
+	/// New head data that should be included in the relay chain state.
+	pub head_data: parachain::HeadData,
+	/// Outgoing messages (a vec for each parachain).
+	pub egress_queues: Vec<Vec<EgressPost>>,
+	/// Balance uploads
+	pub balance_uploads: Vec<BalanceUpload>,
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use substrate_serializer as ser;
+
+	#[test]
+	fn test_validation_result() {
+		assert_eq!(ser::to_string_pretty(&ValidationResult {
+	head_data: parachain::HeadData(vec![1]),
+	egress_queues: vec![vec![EgressPost(vec![1])]],
+	balance_uploads: vec![BalanceUpload(vec![2])],
+			}), r#"{
+  "headData": "0x01",
+  "egressQueues": [
+    [
+      "0x01"
+    ]
+  ],
+  "balanceUploads": [
+    "0x02"
+  ]
+}"#);
+	}
+}