Phase 1 of repo reorg (#719)

* Remove unneeded script

* Rename Substrate Demo -> Substrate

* Rename demo -> node

* Build wasm from last rename.

* Merge ed25519 into substrate-primitives

* Minor tweak

* Rename substrate -> core

* Move substrate-runtime-support to core/runtime/support

* Rename/move substrate-runtime-version

* Move codec up a level

* Rename substrate-codec -> parity-codec

* Move environmental up a level

* Move pwasm-* up to top, ready for removal

* Remove requirement of s-r-support from s-r-primitives

* Move core/runtime/primitives into core/runtime-primitives

* Remove s-r-support dep from s-r-version

* Remove dep of s-r-support from bft

* Remove dep of s-r-support from node/consensus

* Sever all other core deps from s-r-support

* Forgot the no_std directive

* Rename non-SRML modules to sr-* to avoid match clashes

* Move runtime/* to srml/*

* Rename substrate-runtime-* -> srml-*

* Move srml to top-level

substrate/core/sr-primitives/src/generic/block.rs

@@ -0,0 +1,105 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate 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.
+
+// Substrate 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 Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Generic implementation of a block and associated items.
+
+#[cfg(feature = "std")]
+use std::fmt;
+
+use rstd::prelude::*;
+use codec::Codec;
+use traits::{self, Member, Block as BlockT, Header as HeaderT};
+use bft::Justification;
+
+/// Something to identify a block.
+#[derive(PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "std", derive(Debug, Serialize))]
+#[cfg_attr(feature = "std", serde(rename_all = "camelCase"))]
+#[cfg_attr(feature = "std", serde(deny_unknown_fields))]
+pub enum BlockId<Block: BlockT> {
+	/// Identify by block header hash.
+	Hash(<<Block as BlockT>::Header as HeaderT>::Hash),
+	/// Identify by block number.
+	Number(<<Block as BlockT>::Header as HeaderT>::Number),
+}
+
+impl<Block: BlockT> BlockId<Block> {
+	/// Create a block ID from a hash.
+	pub fn hash(hash: Block::Hash) -> Self {
+		BlockId::Hash(hash)
+	}
+
+	/// Create a block ID from a number.
+	pub fn number(number: <Block::Header as HeaderT>::Number) -> Self {
+		BlockId::Number(number)
+	}
+}
+
+impl<Block: BlockT> Copy for BlockId<Block> {}
+
+#[cfg(feature = "std")]
+impl<Block: BlockT> fmt::Display for BlockId<Block> {
+	fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+		write!(f, "{:?}", self)
+	}
+}
+
+/// Abstraction over a substrate block.
+#[derive(PartialEq, Eq, Clone, Encode, Decode)]
+#[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 Block<Header, Extrinsic> {
+	/// The block header.
+	pub header: Header,
+	/// The accompanying extrinsics.
+	pub extrinsics: Vec<Extrinsic>,
+}
+
+impl<Header, Extrinsic> traits::Block for Block<Header, Extrinsic>
+where
+	Header: HeaderT,
+	Extrinsic: Member + Codec,
+{
+	type Extrinsic = Extrinsic;
+	type Header = Header;
+	type Hash = <Self::Header as traits::Header>::Hash;
+
+	fn header(&self) -> &Self::Header {
+		&self.header
+	}
+	fn extrinsics(&self) -> &[Self::Extrinsic] {
+		&self.extrinsics[..]
+	}
+	fn deconstruct(self) -> (Self::Header, Vec<Self::Extrinsic>) {
+		(self.header, self.extrinsics)
+	}
+	fn new(header: Self::Header, extrinsics: Vec<Self::Extrinsic>) -> Self {
+		Block { header, extrinsics }
+	}
+}
+
+/// Abstraction over a substrate block and justification.
+#[derive(PartialEq, Eq, Clone, Encode, Decode)]
+#[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 SignedBlock<Header, Extrinsic, Hash> {
+	/// Full block.
+	pub block: Block<Header, Extrinsic>,
+	/// Block header justification.
+	pub justification: Justification<Hash>,
+}

substrate/core/sr-primitives/src/generic/checked_extrinsic.rs

@@ -0,0 +1,58 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate 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.
+
+// Substrate 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 Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Generic implementation of an extrinsic that has passed the verification
+//! stage.
+
+use traits::{self, Member, SimpleArithmetic, MaybeDisplay};
+
+/// Definition of something that the external world might want to say; its
+/// existence implies that it has been checked and is good, particularly with
+/// regards to the signature.
+#[derive(PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+pub struct CheckedExtrinsic<AccountId, Index, Call> {
+	/// Who this purports to be from, if anyone (note this is not a signature).
+	pub signed: Option<AccountId>,
+	/// The number of extrinsics have come before from the same signer.
+	pub index: Index,
+	/// The function that should be called.
+	pub function: Call,
+}
+
+impl<AccountId, Index, Call> traits::Applyable
+	for CheckedExtrinsic<AccountId, Index, Call>
+where
+	AccountId: Member + MaybeDisplay,
+	Index: Member + MaybeDisplay + SimpleArithmetic,
+	Call: Member 
+{
+	type Index = Index;
+	type AccountId = AccountId;
+	type Call = Call;
+
+	fn index(&self) -> &Self::Index {
+		&self.index
+	}
+
+	fn sender(&self) -> Option<&Self::AccountId> {
+		self.signed.as_ref()
+	}
+
+	fn deconstruct(self) -> (Self::Call, Option<Self::AccountId>) {
+		(self.function, self.signed)
+	}
+}

substrate/core/sr-primitives/src/generic/digest.rs

@@ -0,0 +1,150 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate 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.
+
+// Substrate 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 Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Generic implementation of a digest.
+
+use rstd::prelude::*;
+
+use codec::{Decode, Encode, Codec, Input};
+use traits::{self, Member, DigestItem as DigestItemT};
+
+#[derive(PartialEq, Eq, Clone, Encode, Decode)]
+#[cfg_attr(feature = "std", derive(Debug, Serialize, Deserialize))]
+pub struct Digest<Item> {
+	pub logs: Vec<Item>,
+}
+
+impl<Item> Default for Digest<Item> {
+	fn default() -> Self {
+		Digest { logs: Vec::new(), }
+	}
+}
+
+impl<Item> traits::Digest for Digest<Item> where
+	Item: DigestItemT + Codec
+{
+	type Item = Item;
+
+	fn logs(&self) -> &[Self::Item] {
+		&self.logs
+	}
+
+	fn push(&mut self, item: Self::Item) {
+		self.logs.push(item);
+	}
+}
+
+/// Digest item that is able to encode/decode 'system' digest items and
+/// provide opaque access to other items.
+#[derive(PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "std", derive(Debug, Serialize, Deserialize))]
+pub enum DigestItem<AuthorityId> {
+	/// System digest item announcing that authorities set has been changed
+	/// in the block. Contains the new set of authorities.
+	AuthoritiesChange(Vec<AuthorityId>),
+	/// Any 'non-system' digest item, opaque to the native code.
+	Other(Vec<u8>),
+}
+
+/// A 'referencing view' for digest item. Does not own its contents. Used by
+/// final runtime implementations for encoding/decoding its log items.
+#[derive(PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "std", derive(Debug))]
+pub enum DigestItemRef<'a, AuthorityId: 'a> {
+	/// Reference to `DigestItem::AuthoritiesChange`.
+	AuthoritiesChange(&'a [AuthorityId]),
+	/// Reference to `DigestItem::Other`.
+	Other(&'a Vec<u8>),
+}
+
+/// Type of the digest item. Used to gain explicit control over `DigestItem` encoding
+/// process. We need an explicit control, because final runtimes are encoding their own
+/// digest items using `DigestItemRef` type and we can't auto-derive `Decode`
+/// trait for `DigestItemRef`.
+#[repr(u32)]
+#[derive(Encode, Decode)]
+enum DigestItemType {
+	Other = 0,
+	AuthoritiesChange,
+}
+
+impl<AuthorityId> DigestItem<AuthorityId> {
+	/// Returns Some if `self` is a `DigestItem::Other`.
+	pub fn as_other(&self) -> Option<&Vec<u8>> {
+		match *self {
+			DigestItem::Other(ref v) => Some(v),
+			_ => None,
+		}
+	}
+
+	/// Returns a 'referencing view' for this digest item.
+	fn dref<'a>(&'a self) -> DigestItemRef<'a, AuthorityId> {
+		match *self {
+			DigestItem::AuthoritiesChange(ref v) => DigestItemRef::AuthoritiesChange(v),
+			DigestItem::Other(ref v) => DigestItemRef::Other(v),
+		}
+	}
+}
+
+impl<AuthorityId: Member> traits::DigestItem for DigestItem<AuthorityId> {
+	type AuthorityId = AuthorityId;
+
+	fn as_authorities_change(&self) -> Option<&[Self::AuthorityId]> {
+		match *self {
+			DigestItem::AuthoritiesChange(ref authorities) => Some(authorities),
+			_ => None,
+		}
+	}
+}
+
+impl<AuthorityId: Encode> Encode for DigestItem<AuthorityId> {
+	fn encode(&self) -> Vec<u8> {
+		self.dref().encode()
+	}
+}
+
+impl<AuthorityId: Decode> Decode for DigestItem<AuthorityId> {
+	fn decode<I: Input>(input: &mut I) -> Option<Self> {
+		let item_type: DigestItemType = Decode::decode(input)?;
+		match item_type {
+			DigestItemType::AuthoritiesChange => Some(DigestItem::AuthoritiesChange(
+				Decode::decode(input)?,
+			)),
+			DigestItemType::Other => Some(DigestItem::Other(
+				Decode::decode(input)?,
+			)),
+		}
+	}
+}
+
+impl<'a, AuthorityId: Encode> Encode for DigestItemRef<'a, AuthorityId> {
+	fn encode(&self) -> Vec<u8> {
+		let mut v = Vec::new();
+
+		match *self {
+			DigestItemRef::AuthoritiesChange(authorities) => {
+				DigestItemType::AuthoritiesChange.encode_to(&mut v);
+				authorities.encode_to(&mut v);
+			},
+			DigestItemRef::Other(val) => {
+				DigestItemType::Other.encode_to(&mut v);
+				val.encode_to(&mut v);
+			},
+		}
+
+		v
+	}
+}

substrate/core/sr-primitives/src/generic/header.rs

@@ -0,0 +1,167 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate 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.
+
+// Substrate 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 Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Generic implementation of a block header.
+
+#[cfg(feature = "std")]
+use serde::{Deserialize, Deserializer};
+
+use codec::{Decode, Encode, Codec, Input, Output};
+use traits::{self, Member, SimpleArithmetic, SimpleBitOps, MaybeDisplay,
+	Hash as HashT, DigestItem as DigestItemT};
+use generic::Digest;
+
+/// Abstraction over a block header for a substrate chain.
+#[derive(PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "std", derive(Debug, Serialize))]
+#[cfg_attr(feature = "std", serde(rename_all = "camelCase"))]
+#[cfg_attr(feature = "std", serde(deny_unknown_fields))]
+pub struct Header<Number, Hash: HashT, DigestItem> {
+	/// The parent hash.
+	pub parent_hash: <Hash as HashT>::Output,
+	/// The block number.
+	pub number: Number,
+	/// The state trie merkle root
+	pub state_root: <Hash as HashT>::Output,
+	/// The merkle root of the extrinsics.
+	pub extrinsics_root: <Hash as HashT>::Output,
+	/// A chain-specific digest of data useful for light clients or referencing auxiliary data.
+	pub digest: Digest<DigestItem>,
+}
+
+// Hack to work around the fact that deriving deserialize doesn't work nicely with
+// the `hashing` trait used as a parameter.
+// dummy struct that uses the hash type directly.
+// https://github.com/serde-rs/serde/issues/1296
+#[cfg(feature = "std")]
+#[serde(rename_all = "camelCase")]
+#[derive(Deserialize)]
+struct DeserializeHeader<N, H, D> {
+	parent_hash: H,
+	number: N,
+	state_root: H,
+	extrinsics_root: H,
+	digest: Digest<D>,
+}
+
+#[cfg(feature = "std")]
+impl<N, D, Hash: HashT> From<DeserializeHeader<N, Hash::Output, D>> for Header<N, Hash, D> {
+	fn from(other: DeserializeHeader<N, Hash::Output, D>) -> Self {
+		Header {
+			parent_hash: other.parent_hash,
+			number: other.number,
+			state_root: other.state_root,
+			extrinsics_root: other.extrinsics_root,
+			digest: other.digest,
+		}
+	}
+}
+
+#[cfg(feature = "std")]
+impl<'a, Number: 'a, Hash: 'a + HashT, DigestItem: 'a> Deserialize<'a> for Header<Number, Hash, DigestItem> where
+	Number: Deserialize<'a>,
+	Hash::Output: Deserialize<'a>,
+	DigestItem: Deserialize<'a>,
+{
+	fn deserialize<D: Deserializer<'a>>(de: D) -> Result<Self, D::Error> {
+		DeserializeHeader::<Number, Hash::Output, DigestItem>::deserialize(de).map(Into::into)
+	}
+}
+
+// TODO [ToDr] Issue with bounds
+impl<Number, Hash, DigestItem> Decode for Header<Number, Hash, DigestItem> where
+	Number: Decode,
+	Hash: HashT,
+	Hash::Output: Decode,
+	DigestItem: DigestItemT + Decode,
+{
+	fn decode<I: Input>(input: &mut I) -> Option<Self> {
+		Some(Header {
+			parent_hash: Decode::decode(input)?,
+			number: Decode::decode(input)?,
+			state_root: Decode::decode(input)?,
+			extrinsics_root: Decode::decode(input)?,
+			digest: Decode::decode(input)?,
+		})
+	}
+}
+
+impl<Number, Hash, DigestItem> Encode for Header<Number, Hash, DigestItem> where
+	Number: Encode,
+	Hash: HashT,
+	Hash::Output: Encode,
+	DigestItem: DigestItemT + Encode,
+{
+	fn encode_to<T: Output>(&self, dest: &mut T) {
+		dest.push(&self.parent_hash);
+		dest.push(&self.number);
+		dest.push(&self.state_root);
+		dest.push(&self.extrinsics_root);
+		dest.push(&self.digest);
+	}
+}
+
+impl<Number, Hash, DigestItem> traits::Header for Header<Number, Hash, DigestItem> where
+	Number: Member + ::rstd::hash::Hash + Copy + Codec + MaybeDisplay + SimpleArithmetic + Codec,
+	Hash: HashT,
+	DigestItem: DigestItemT + Codec,
+	Hash::Output: Default + ::rstd::hash::Hash + Copy + Member + MaybeDisplay + SimpleBitOps + Codec,
+ {
+	type Number = Number;
+	type Hash = <Hash as HashT>::Output;
+	type Hashing = Hash;
+	type Digest = Digest<DigestItem>;
+
+	fn number(&self) -> &Self::Number { &self.number }
+	fn set_number(&mut self, num: Self::Number) { self.number = num }
+
+	fn extrinsics_root(&self) -> &Self::Hash { &self.extrinsics_root }
+	fn set_extrinsics_root(&mut self, root: Self::Hash) { self.extrinsics_root = root }
+
+	fn state_root(&self) -> &Self::Hash { &self.state_root }
+	fn set_state_root(&mut self, root: Self::Hash) { self.state_root = root }
+
+	fn parent_hash(&self) -> &Self::Hash { &self.parent_hash }
+	fn set_parent_hash(&mut self, hash: Self::Hash) { self.parent_hash = hash }
+
+	fn digest(&self) -> &Self::Digest { &self.digest }
+	fn set_digest(&mut self, digest: Self::Digest) { self.digest = digest }
+
+	fn new(
+		number: Self::Number,
+		extrinsics_root: Self::Hash,
+		state_root: Self::Hash,
+		parent_hash: Self::Hash,
+		digest: Self::Digest
+	) -> Self {
+		Header {
+			number, extrinsics_root: extrinsics_root, state_root, parent_hash, digest
+		}
+	}
+}
+
+impl<Number, Hash, DigestItem> Header<Number, Hash, DigestItem> where
+	Number: Member + ::rstd::hash::Hash + Copy + Codec + MaybeDisplay + SimpleArithmetic + Codec,
+	Hash: HashT,
+	DigestItem: DigestItemT + Codec,
+	Hash::Output: Default + ::rstd::hash::Hash + Copy + Member + MaybeDisplay + SimpleBitOps + Codec,
+ {
+	/// Convenience helper for computing the hash of the header without having
+	/// to import the trait.
+	pub fn hash(&self) -> Hash::Output {
+		Hash::hash_of(self)
+	}
+}

substrate/core/sr-primitives/src/generic/mod.rs

@@ -0,0 +1,33 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate 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.
+
+// Substrate 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 Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+// tag::description[]
+//! Generic implementations of Extrinsic/Header/Block.
+// end::description[]
+
+mod unchecked_extrinsic;
+mod checked_extrinsic;
+mod header;
+mod block;
+mod digest;
+#[cfg(test)]
+mod tests;
+
+pub use self::unchecked_extrinsic::UncheckedExtrinsic;
+pub use self::checked_extrinsic::CheckedExtrinsic;
+pub use self::header::Header;
+pub use self::block::{Block, SignedBlock, BlockId};
+pub use self::digest::{Digest, DigestItem, DigestItemRef};

substrate/core/sr-primitives/src/generic/tests.rs

@@ -0,0 +1,105 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate 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.
+
+// Substrate 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 Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Tests for the generic implementations of Extrinsic/Header/Block.
+
+use codec::{Decode, Encode};
+use substrate_primitives::{H256, H512};
+use super::{Digest, Header, DigestItem, UncheckedExtrinsic};
+
+type Block = super::Block<
+	Header<u64, ::traits::BlakeTwo256, DigestItem<u32>>,
+	UncheckedExtrinsic<H256, u64, u64, ::Ed25519Signature>,
+>;
+
+#[test]
+fn block_roundtrip_serialization() {
+	let block: Block = Block {
+		header: Header {
+			parent_hash: [0u8; 32].into(),
+			number: 100_000,
+			state_root: [1u8; 32].into(),
+			extrinsics_root: [2u8; 32].into(),
+			digest: Digest { logs: vec![
+				DigestItem::Other::<u32>(vec![1, 2, 3]),
+				DigestItem::Other::<u32>(vec![4, 5, 6]),
+			] },
+		},
+		extrinsics: vec![
+			UncheckedExtrinsic::new_signed(
+				0,
+				100,
+				[255u8; 32].into(),
+				H512::from([0u8; 64]).into()
+			),
+			UncheckedExtrinsic::new_signed(
+				100,
+				99,
+				[128u8; 32].into(),
+				H512::from([255u8; 64]).into()
+			)
+		]
+	};
+
+	{
+		let encoded = ::serde_json::to_vec(&block).unwrap();
+		let decoded: Block = ::serde_json::from_slice(&encoded).unwrap();
+
+		assert_eq!(block, decoded);
+	}
+	{
+		let encoded = block.encode();
+		let decoded = Block::decode(&mut &encoded[..]).unwrap();
+
+		assert_eq!(block, decoded);
+	}
+}
+
+#[test]
+fn system_digest_item_encoding() {
+	let item = DigestItem::AuthoritiesChange::<u32>(vec![10, 20, 30]);
+	let encoded = item.encode();
+	assert_eq!(encoded, vec![
+		// type = DigestItemType::AuthoritiesChange
+		1,
+		// number of items in athorities set
+		3, 0, 0, 0,
+		// authorities
+		10, 0, 0, 0,
+		20, 0, 0, 0,
+		30, 0, 0, 0,
+	]);
+
+	let decoded: DigestItem<u32> = Decode::decode(&mut &encoded[..]).unwrap();
+	assert_eq!(item, decoded);
+}
+
+#[test]
+fn non_system_digest_item_encoding() {
+	let item = DigestItem::Other::<u32>(vec![10, 20, 30]);
+	let encoded = item.encode();
+	assert_eq!(encoded, vec![
+		// type = DigestItemType::Other
+		0,
+		// length of other data
+		3, 0, 0, 0,
+		// authorities
+		10, 20, 30,
+	]);
+
+	let decoded: DigestItem<u32> = Decode::decode(&mut &encoded[..]).unwrap();
+	assert_eq!(item, decoded);
+}

substrate/core/sr-primitives/src/generic/unchecked_extrinsic.rs

@@ -0,0 +1,159 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate 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.
+
+// Substrate 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 Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Generic implementation of an unchecked (pre-verification) extrinsic.
+
+#[cfg(feature = "std")]
+use std::fmt;
+
+use rstd::prelude::*;
+use codec::{Decode, Encode, Input};
+use traits::{self, Member, SimpleArithmetic, MaybeDisplay};
+use super::CheckedExtrinsic;
+
+/// A extrinsic right from the external world. This is unchecked and so
+/// can contain a signature.
+#[derive(PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
+pub struct UncheckedExtrinsic<Address, Index, Call, Signature> {
+	/// The signature and address, if this is a signed extrinsic.
+	pub signature: Option<(Address, Signature)>,
+	/// The number of extrinsics have come before from the same signer.
+	pub index: Index,
+	/// The function that should be called.
+	pub function: Call,
+}
+
+impl<Address, Index, Call, Signature> UncheckedExtrinsic<Address, Index, Call, Signature> {
+	/// New instance of a signed extrinsic aka "transaction".
+	pub fn new_signed(index: Index, function: Call, signed: Address, signature: Signature) -> Self {
+		UncheckedExtrinsic {
+			signature: Some((signed, signature)),
+			index,
+			function,
+		}
+	}
+
+	/// New instance of an unsigned extrinsic aka "inherent".
+	pub fn new_unsigned(index: Index, function: Call) -> Self {
+		UncheckedExtrinsic {
+			signature: None,
+			index,
+			function,
+		}
+	}
+
+	/// `true` if there is a signature.
+	pub fn is_signed(&self) -> bool {
+		self.signature.is_some()
+	}
+}
+
+impl<Address, AccountId, Index, Call, Signature, ThisLookup> traits::Checkable<ThisLookup>
+	for UncheckedExtrinsic<Address, Index, Call, Signature>
+where
+	Address: Member + MaybeDisplay,
+	Index: Encode + Member + MaybeDisplay + SimpleArithmetic,
+	Call: Encode + Member,
+	Signature: Member + traits::Verify<Signer=AccountId>,
+	AccountId: Member + MaybeDisplay,
+	ThisLookup: FnOnce(Address) -> Result<AccountId, &'static str>,
+{
+	type Checked = CheckedExtrinsic<AccountId, Index, Call>;
+
+	fn check_with(self, lookup: ThisLookup) -> Result<Self::Checked, &'static str> {
+		Ok(match self.signature {
+			Some((signed, signature)) => {
+				let payload = (self.index, self.function);
+				let signed = lookup(signed)?;
+				if !::verify_encoded_lazy(&signature, &payload, &signed) {
+					return Err("bad signature in extrinsic")
+				}
+				CheckedExtrinsic {
+					signed: Some(signed),
+					index: payload.0,
+					function: payload.1,
+				}
+			}
+			None => CheckedExtrinsic {
+				signed: None,
+				index: self.index,
+				function: self.function,
+			},
+		})
+	}
+}
+
+impl<Address, Index, Call, Signature> Decode
+	for UncheckedExtrinsic<Address, Index, Call, Signature>
+where
+	Address: Decode,
+	Signature: Decode,
+	Index: Decode,
+	Call: Decode,
+{
+	fn decode<I: Input>(input: &mut I) -> Option<Self> {
+		// This is a little more complicated than usual 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 = Decode::decode(input)?;
+
+		Some(UncheckedExtrinsic {
+			signature: Decode::decode(input)?,
+			index: Decode::decode(input)?,
+			function: Decode::decode(input)?,
+		})
+	}
+}
+
+impl<Address, Index, Call, Signature> Encode
+	for UncheckedExtrinsic<Address, Index, Call, Signature>
+where
+	Address: Encode,
+	Signature: Encode,
+	Index: Encode,
+	Call: Encode,
+{
+	fn encode(&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.signature.encode_to(&mut v);
+		self.index.encode_to(&mut v);
+		self.function.encode_to(&mut v);
+
+		let length = (v.len() - 4) as u32;
+		length.using_encoded(|s| v[0..4].copy_from_slice(s));
+
+		v
+	}
+}
+
+/// TODO: use derive when possible.
+#[cfg(feature = "std")]
+impl<Address, Index, Call, Signature> fmt::Debug for UncheckedExtrinsic<Address, Index, Call, Signature> where
+	Address: fmt::Debug,
+	Index: fmt::Debug,
+	Call: fmt::Debug,
+{
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		write!(f, "UncheckedExtrinsic({:?}, {:?}, {:?})", self.signature.as_ref().map(|x| &x.0), self.function, self.index)
+	}
+}