Merge branch 'master' into rh-grandpa-dynamic2

substrate/core/sr-primitives/Cargo.toml

@@ -13,7 +13,6 @@ parity-codec-derive = { version = "2.1", default-features = false }
 substrate-primitives = { path = "../primitives", default-features = false }
 sr-std = { path = "../sr-std", default-features = false }
 sr-io = { path = "../sr-io", default-features = false }
-sr-version = { path = "../sr-version", default-features = false }
 log = {version = "0.4", optional = true }
 
 [dev-dependencies]
@@ -28,7 +27,6 @@ std = [
 	"log",
 	"sr-std/std",
 	"sr-io/std",
-	"sr-version/std",
 	"parity-codec/std",
 	"substrate-primitives/std",
 ]

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

@@ -72,7 +72,7 @@ pub struct Block<Header, Extrinsic> {
 impl<Header, Extrinsic> traits::Block for Block<Header, Extrinsic>
 where
 	Header: HeaderT,
-	Extrinsic: Member + Codec,
+	Extrinsic: Member + Codec + traits::Extrinsic,
 {
 	type Extrinsic = Extrinsic;
 	type Header = Header;
@@ -102,4 +102,4 @@ pub struct SignedBlock<H, E> {
 	pub block: Block<H, E>,
 	/// Block justification.
 	pub justification: Justification,
-}
+}

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

@@ -113,17 +113,11 @@ impl<Hash: Codec + Member, AuthorityId: Codec + Member> traits::DigestItem for D
 	type AuthorityId = AuthorityId;
 
 	fn as_authorities_change(&self) -> Option<&[Self::AuthorityId]> {
-		match *self {
-			DigestItem::AuthoritiesChange(ref authorities) => Some(authorities),
-			_ => None,
-		}
+		self.dref().as_authorities_change()
 	}
 
 	fn as_changes_trie_root(&self) -> Option<&Hash> {
-		match *self {
-			DigestItem::ChangesTrieRoot(ref changes_trie_root) => Some(changes_trie_root),
-			_ => None,
-		}
+		self.dref().as_changes_trie_root()
 	}
 }
 
@@ -150,6 +144,22 @@ impl<Hash: Decode, AuthorityId: Decode> Decode for DigestItem<Hash, AuthorityId>
 	}
 }
 
+impl<'a, Hash: Codec + Member, AuthorityId: Codec + Member> DigestItemRef<'a, Hash, AuthorityId> {
+	pub fn as_authorities_change(&self) -> Option<&'a [AuthorityId]> {
+		match *self {
+			DigestItemRef::AuthoritiesChange(ref authorities) => Some(authorities),
+			_ => None,
+		}
+	}
+
+	pub fn as_changes_trie_root(&self) -> Option<&'a Hash> {
+		match *self {
+			DigestItemRef::ChangesTrieRoot(ref changes_trie_root) => Some(changes_trie_root),
+			_ => None,
+		}
+	}
+}
+
 impl<'a, Hash: Encode, AuthorityId: Encode> Encode for DigestItemRef<'a, Hash, AuthorityId> {
 	fn encode(&self) -> Vec<u8> {
 		let mut v = Vec::new();

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

@@ -22,7 +22,7 @@ use std::fmt;
 use rstd::prelude::*;
 use codec::{Decode, Encode, Input};
 use traits::{self, Member, SimpleArithmetic, MaybeDisplay, CurrentHeight, BlockNumberToHash, Lookup,
-	Checkable};
+	Checkable, Extrinsic};
 use super::{CheckedExtrinsic, Era};
 
 const TRANSACTION_VERSION: u8 = 1;
@@ -56,10 +56,11 @@ impl<Address, Index, Call, Signature> UncheckedMortalExtrinsic<Address, Index, C
 			function,
 		}
 	}
+}
 
-	/// `true` if there is a signature.
-	pub fn is_signed(&self) -> bool {
-		self.signature.is_some()
+impl<Address, Index, Call, Signature> Extrinsic for UncheckedMortalExtrinsic<Address, Index, Call, Signature> {
+	fn is_signed(&self) -> Option<bool> {
+		Some(self.signature.is_some())
 	}
 }
 
@@ -221,49 +222,49 @@ mod tests {
 	#[test]
 	fn unsigned_check_should_work() {
 		let ux = Ex::new_unsigned(DUMMY_FUNCTION);
-		assert!(!ux.is_signed());
+		assert!(!ux.is_signed().unwrap_or(false));
 		assert!(<Ex as Checkable<TestContext>>::check(ux, &TestContext).is_ok());
 	}
 
 	#[test]
 	fn badly_signed_check_should_fail() {
 		let ux = Ex::new_signed(0, DUMMY_FUNCTION, DUMMY_ACCOUNTID, TestSig(DUMMY_ACCOUNTID, vec![0u8]), Era::immortal());
-		assert!(ux.is_signed());
+		assert!(ux.is_signed().unwrap_or(false));
 		assert_eq!(<Ex as Checkable<TestContext>>::check(ux, &TestContext), Err("bad signature in extrinsic"));
 	}
 
 	#[test]
 	fn immortal_signed_check_should_work() {
 		let ux = Ex::new_signed(0, DUMMY_FUNCTION, DUMMY_ACCOUNTID, TestSig(DUMMY_ACCOUNTID, (DUMMY_ACCOUNTID, DUMMY_FUNCTION, Era::immortal(), 0u64).encode()), Era::immortal());
-		assert!(ux.is_signed());
+		assert!(ux.is_signed().unwrap_or(false));
 		assert_eq!(<Ex as Checkable<TestContext>>::check(ux, &TestContext), Ok(CEx { signed: Some((DUMMY_ACCOUNTID, 0)), function: DUMMY_FUNCTION }));
 	}
 
 	#[test]
 	fn mortal_signed_check_should_work() {
 		let ux = Ex::new_signed(0, DUMMY_FUNCTION, DUMMY_ACCOUNTID, TestSig(DUMMY_ACCOUNTID, (DUMMY_ACCOUNTID, DUMMY_FUNCTION, Era::mortal(32, 42), 42u64).encode()), Era::mortal(32, 42));
-		assert!(ux.is_signed());
+		assert!(ux.is_signed().unwrap_or(false));
 		assert_eq!(<Ex as Checkable<TestContext>>::check(ux, &TestContext), Ok(CEx { signed: Some((DUMMY_ACCOUNTID, 0)), function: DUMMY_FUNCTION }));
 	}
 
 	#[test]
 	fn later_mortal_signed_check_should_work() {
 		let ux = Ex::new_signed(0, DUMMY_FUNCTION, DUMMY_ACCOUNTID, TestSig(DUMMY_ACCOUNTID, (DUMMY_ACCOUNTID, DUMMY_FUNCTION, Era::mortal(32, 11), 11u64).encode()), Era::mortal(32, 11));
-		assert!(ux.is_signed());
+		assert!(ux.is_signed().unwrap_or(false));
 		assert_eq!(<Ex as Checkable<TestContext>>::check(ux, &TestContext), Ok(CEx { signed: Some((DUMMY_ACCOUNTID, 0)), function: DUMMY_FUNCTION }));
 	}
 
 	#[test]
 	fn too_late_mortal_signed_check_should_fail() {
 		let ux = Ex::new_signed(0, DUMMY_FUNCTION, DUMMY_ACCOUNTID, TestSig(DUMMY_ACCOUNTID, (DUMMY_ACCOUNTID, DUMMY_FUNCTION, Era::mortal(32, 10), 10u64).encode()), Era::mortal(32, 10));
-		assert!(ux.is_signed());
+		assert!(ux.is_signed().unwrap_or(false));
 		assert_eq!(<Ex as Checkable<TestContext>>::check(ux, &TestContext), Err("bad signature in extrinsic"));
 	}
 
 	#[test]
 	fn too_early_mortal_signed_check_should_fail() {
 		let ux = Ex::new_signed(0, DUMMY_FUNCTION, DUMMY_ACCOUNTID, TestSig(DUMMY_ACCOUNTID, (DUMMY_ACCOUNTID, DUMMY_FUNCTION, Era::mortal(32, 43), 43u64).encode()), Era::mortal(32, 43));
-		assert!(ux.is_signed());
+		assert!(ux.is_signed().unwrap_or(false));
 		assert_eq!(<Ex as Checkable<TestContext>>::check(ux, &TestContext), Err("bad signature in extrinsic"));
 	}
 

substrate/core/sr-primitives/src/lib.rs

@@ -37,7 +37,6 @@ extern crate num_traits;
 extern crate integer_sqrt;
 extern crate sr_std as rstd;
 extern crate sr_io as runtime_io;
-extern crate sr_version as runtime_version;
 #[doc(hidden)]
 pub extern crate parity_codec as codec;
 extern crate substrate_primitives;
@@ -65,6 +64,12 @@ pub type Justification = Vec<u8>;
 
 use traits::{Verify, Lazy};
 
+/// A String that is a `&'static str` on `no_std` and a `String` on `std`.
+#[cfg(not(feature = "std"))]
+pub type RuntimeString = &'static str;
+#[cfg(feature = "std")]
+pub type RuntimeString = ::std::borrow::Cow<'static, str>;
+
 #[cfg(feature = "std")]
 pub use serde::{Serialize, de::DeserializeOwned};
 
@@ -264,19 +269,32 @@ pub fn verify_encoded_lazy<V: Verify, T: codec::Encode>(sig: &V, item: &T, signe
 
 #[macro_export]
 macro_rules! __impl_outer_config_types {
-	($concrete:ident $config:ident $snake:ident $($rest:ident)*) => {
+	(
+		$concrete:ident $config:ident $snake:ident < $ignore:ident > $( $rest:tt )*
+	) => {
 		#[cfg(any(feature = "std", test))]
 		pub type $config = $snake::GenesisConfig<$concrete>;
 		__impl_outer_config_types! {$concrete $($rest)*}
 	};
+	(
+		$concrete:ident $config:ident $snake:ident $( $rest:tt )*
+	) => {
+		#[cfg(any(feature = "std", test))]
+		pub type $config = $snake::GenesisConfig;
+		__impl_outer_config_types! {$concrete $($rest)*}
+	};
 	($concrete:ident) => ()
 }
 
 #[macro_export]
 /// Implement the output "meta" module configuration struct.
 macro_rules! impl_outer_config {
-	( pub struct $main:ident for $concrete:ident { $( $config:ident => $snake:ident, )* } ) => {
-		__impl_outer_config_types! { $concrete $( $config $snake )* }
+	(
+		pub struct $main:ident for $concrete:ident {
+			$( $config:ident => $snake:ident $( < $generic:ident > )*, )*
+		}
+	) => {
+		__impl_outer_config_types! { $concrete $( $config $snake $( < $generic > )* )* }
 		#[cfg(any(feature = "std", test))]
 		#[derive(Serialize, Deserialize)]
 		#[serde(rename_all = "camelCase")]
@@ -321,7 +339,7 @@ macro_rules! impl_outer_log {
 	(
 		$(#[$attr:meta])*
 		pub enum $name:ident ($internal:ident: DigestItem<$( $genarg:ty ),*>) for $trait:ident {
-			$( $module:ident($( $item:ident ),*) ),*
+			$( $module:ident( $( $sitem:ident ),* ) ),*
 		}
 	) => {
 		/// Wrapper for all possible log entries for the `$trait` runtime. Provides binary-compatible
@@ -338,7 +356,7 @@ macro_rules! impl_outer_log {
 		#[cfg_attr(feature = "std", derive(Debug, Serialize, Deserialize))]
 		$(#[$attr])*
 		#[allow(non_camel_case_types)]
-		enum $internal {
+		pub enum InternalLog {
 			$(
 				$module($module::Log<$trait>),
 			)*
@@ -352,14 +370,27 @@ macro_rules! impl_outer_log {
 			fn dref<'a>(&'a self) -> Option<$crate::generic::DigestItemRef<'a, $($genarg),*>> {
 				match self.0 {
 					$($(
-					$internal::$module($module::RawLog::$item(ref v)) =>
-						Some($crate::generic::DigestItemRef::$item(v)),
+					$internal::$module($module::RawLog::$sitem(ref v)) =>
+						Some($crate::generic::DigestItemRef::$sitem(v)),
 					)*)*
 					_ => None,
 				}
 			}
 		}
 
+		impl $crate::traits::DigestItem for $name {
+			type Hash = <$crate::generic::DigestItem<$($genarg),*> as $crate::traits::DigestItem>::Hash;
+			type AuthorityId = <$crate::generic::DigestItem<$($genarg),*> as $crate::traits::DigestItem>::AuthorityId;
+
+			fn as_authorities_change(&self) -> Option<&[Self::AuthorityId]> {
+				self.dref().and_then(|dref| dref.as_authorities_change())
+			}
+
+			fn as_changes_trie_root(&self) -> Option<&Self::Hash> {
+				self.dref().and_then(|dref| dref.as_changes_trie_root())
+			}
+		}
+
 		impl From<$crate::generic::DigestItem<$($genarg),*>> for $name {
 			/// Converts `generic::DigestItem` into `$name`. If `generic::DigestItem` represents
 			/// a system item which is supported by the runtime, it is returned.
@@ -370,8 +401,8 @@ macro_rules! impl_outer_log {
 			fn from(gen: $crate::generic::DigestItem<$($genarg),*>) -> Self {
 				match gen {
 					$($(
-					$crate::generic::DigestItem::$item(value) =>
-						$name($internal::$module($module::RawLog::$item(value))),
+					$crate::generic::DigestItem::$sitem(value) =>
+						$name($internal::$module($module::RawLog::$sitem(value))),
 					)*)*
 					_ => gen.as_other()
 						.and_then(|value| $crate::codec::Decode::decode(&mut &value[..]))
@@ -412,10 +443,10 @@ macro_rules! impl_outer_log {
 				}
 			}
 
-			impl From<$module::Log<$trait>> for $internal {
+			impl From<$module::Log<$trait>> for InternalLog {
 				/// Converts single module log item into `$internal`.
 				fn from(x: $module::Log<$trait>) -> Self {
-					$internal::$module(x)
+					InternalLog::$module(x)
 				}
 			}
 		)*
@@ -426,6 +457,7 @@ macro_rules! impl_outer_log {
 mod tests {
 	use substrate_primitives::hash::H256;
 	use codec::{Encode as EncodeHidden, Decode as DecodeHidden};
+	use traits::DigestItem;
 
 	pub trait RuntimeT {
 		type AuthorityId;
@@ -437,31 +469,31 @@ mod tests {
 		type AuthorityId = u64;
 	}
 
+	mod a {
+		use super::RuntimeT;
+		pub type Log<R> = RawLog<<R as RuntimeT>::AuthorityId>;
+
+		#[derive(Serialize, Deserialize, Debug, Encode, Decode, PartialEq, Eq, Clone)]
+		pub enum RawLog<AuthorityId> { A1(AuthorityId), AuthoritiesChange(Vec<AuthorityId>), A3(AuthorityId) }
+	}
+
+	mod b {
+		use super::RuntimeT;
+		pub type Log<R> = RawLog<<R as RuntimeT>::AuthorityId>;
+
+		#[derive(Serialize, Deserialize, Debug, Encode, Decode, PartialEq, Eq, Clone)]
+		pub enum RawLog<AuthorityId> { B1(AuthorityId), B2(AuthorityId) }
+	}
+
+	// TODO try to avoid redundant brackets: a(AuthoritiesChange), b
+	impl_outer_log! {
+		pub enum Log(InternalLog: DigestItem<H256, u64>) for Runtime {
+			a(AuthoritiesChange), b()
+		}
+	}
+
 	#[test]
 	fn impl_outer_log_works() {
-		mod a {
-			use super::RuntimeT;
-			pub type Log<R> = RawLog<<R as RuntimeT>::AuthorityId>;
-
-			#[derive(Serialize, Deserialize, Debug, Encode, Decode, PartialEq, Eq, Clone)]
-			pub enum RawLog<AuthorityId> { A1(AuthorityId), AuthoritiesChange(Vec<AuthorityId>), A3(AuthorityId) }
-		}
-
-		mod b {
-			use super::RuntimeT;
-			pub type Log<R> = RawLog<<R as RuntimeT>::AuthorityId>;
-
-			#[derive(Serialize, Deserialize, Debug, Encode, Decode, PartialEq, Eq, Clone)]
-			pub enum RawLog<AuthorityId> { B1(AuthorityId), B2(AuthorityId) }
-		}
-
-		// TODO try to avoid redundant brackets: a(AuthoritiesChange), b
-		impl_outer_log! {
-			pub enum Log(InternalLog: DigestItem<H256, u64>) for Runtime {
-				a(AuthoritiesChange), b()
-			}
-		}
-
 		// encode/decode regular item
 		let b1: Log = b::RawLog::B1::<u64>(777).into();
 		let encoded_b1 = b1.encode();
@@ -487,5 +519,11 @@ mod tests {
 			super::generic::DigestItem::AuthoritiesChange::<H256, u64>(authorities) => assert_eq!(authorities, vec![100, 200, 300]),
 			_ => panic!("unexpected generic_auth_change: {:?}", generic_auth_change),
 		}
+
+		// check that as-style methods are working with system items
+		assert!(auth_change.as_authorities_change().is_some());
+
+		// check that as-style methods are not working with regular items
+		assert!(b1.as_authorities_change().is_none());
 	}
 }

substrate/core/sr-primitives/src/testing.rs

@@ -17,7 +17,7 @@
 //! Testing utilities.
 
 use serde::{Serialize, de::DeserializeOwned};
-use std::fmt::Debug;
+use std::{fmt::Debug, ops::Deref};
 use codec::Codec;
 use traits::{self, Checkable, Applyable, BlakeTwo256};
 use generic::DigestItem as GenDigestItem;
@@ -93,13 +93,36 @@ impl traits::Header for Header {
 	}
 }
 
+#[derive(PartialEq, Eq, Clone, Serialize, Deserialize, Debug, Encode, Decode)]
+pub struct ExtrinsicWrapper<Xt>(Xt);
+
+impl<Xt> traits::Extrinsic for ExtrinsicWrapper<Xt> {
+	fn is_signed(&self) -> Option<bool> {
+		None
+	}
+}
+
+impl<Xt> From<Xt> for ExtrinsicWrapper<Xt> {
+	fn from(xt: Xt) -> Self {
+		ExtrinsicWrapper(xt)
+	}
+}
+
+impl<Xt> Deref for ExtrinsicWrapper<Xt> {
+	type Target = Xt;
+
+	fn deref(&self) -> &Self::Target {
+		&self.0
+	}
+}
+
 #[derive(PartialEq, Eq, Clone, Serialize, Deserialize, Debug, Encode, Decode)]
 pub struct Block<Xt> {
 	pub header: Header,
 	pub extrinsics: Vec<Xt>,
 }
 
-impl<Xt: 'static + Codec + Sized + Send + Sync + Serialize + DeserializeOwned + Clone + Eq + Debug> traits::Block for Block<Xt> {
+impl<Xt: 'static + Codec + Sized + Send + Sync + Serialize + DeserializeOwned + Clone + Eq + Debug + traits::Extrinsic> traits::Block for Block<Xt> {
 	type Extrinsic = Xt;
 	type Header = Header;
 	type Hash = <Header as traits::Header>::Hash;
@@ -125,6 +148,11 @@ impl<Call: Codec + Sync + Send + Serialize, Context> Checkable<Context> for Test
 	type Checked = Self;
 	fn check(self, _: &Context) -> Result<Self::Checked, &'static str> { Ok(self) }
 }
+impl<Call: Codec + Sync + Send + Serialize> traits::Extrinsic for TestXt<Call> {
+	fn is_signed(&self) -> Option<bool> {
+		None
+	}
+}
 impl<Call> Applyable for TestXt<Call> where
 	Call: 'static + Sized + Send + Sync + Clone + Eq + Codec + Debug + Serialize + DeserializeOwned,
 {

substrate/core/sr-primitives/src/traits.rs

@@ -383,6 +383,17 @@ pub trait MaybeDisplay {}
 #[cfg(not(feature = "std"))]
 impl<T> MaybeDisplay for T {}
 
+#[cfg(feature = "std")]
+pub trait MaybeDecode: ::codec::Decode {}
+#[cfg(feature = "std")]
+impl<T: ::codec::Decode> MaybeDecode for T {}
+
+#[cfg(not(feature = "std"))]
+pub trait MaybeDecode {}
+#[cfg(not(feature = "std"))]
+impl<T> MaybeDecode for T {}
+
+
 pub trait Member: Send + Sync + Sized + MaybeSerializeDebug + Eq + PartialEq + Clone + 'static {}
 impl<T: Send + Sync + Sized + MaybeSerializeDebug + Eq + PartialEq + Clone + 'static> Member for T {}
 
@@ -430,7 +441,7 @@ pub trait Header: Clone + Send + Sync + Codec + Eq + MaybeSerializeDebug + 'stat
 ///
 /// You can get an iterator over each of the `extrinsics` and retrieve the `header`.
 pub trait Block: Clone + Send + Sync + Codec + Eq + MaybeSerializeDebug + 'static {
-	type Extrinsic: Member + Codec;
+	type Extrinsic: Member + Codec + Extrinsic;
 	type Header: Header<Hash=Self::Hash>;
 	type Hash: Member + ::rstd::hash::Hash + Copy + MaybeDisplay + Default + SimpleBitOps + Codec + AsRef<[u8]> + AsMut<[u8]>;
 
@@ -527,12 +538,37 @@ pub trait DigestItem: Codec + Member {
 	type AuthorityId: Member;
 
 	/// Returns Some if the entry is the `AuthoritiesChange` entry.
-	fn as_authorities_change(&self) -> Option<&[Self::AuthorityId]> {
-		None
-	}
+	fn as_authorities_change(&self) -> Option<&[Self::AuthorityId]>;
 
 	/// Returns Some if the entry is the `ChangesTrieRoot` entry.
-	fn as_changes_trie_root(&self) -> Option<&Self::Hash> {
-		None
-	}
+	fn as_changes_trie_root(&self) -> Option<&Self::Hash>;
+}
+
+/// Something that provides an inherent for a runtime.
+pub trait ProvideInherent {
+	/// The inherent that is provided.
+	type Inherent: Encode + MaybeDecode;
+	/// The error used by this trait.
+	type Error: Encode + MaybeDecode;
+	/// The call for setting the inherent.
+	type Call: Encode + MaybeDecode;
+
+	/// Create the inherent extrinsics.
+	///
+	/// # Return
+	///
+	/// Returns a vector with tuples containing the index for the extrinsic and the extrinsic itself.
+	fn create_inherent_extrinsics(data: Self::Inherent) -> Vec<(u32, Self::Call)>;
+
+	/// Check that the given inherent is valid.
+	fn check_inherent<Block: self::Block, F: Fn(&Block::Extrinsic) -> Option<&Self::Call>>(
+		block: &Block, data: Self::Inherent, extract_function: &F
+	) -> Result<(), Self::Error>;
+}
+
+/// Something that acts like an `Extrinsic`.
+pub trait Extrinsic {
+	/// Is this `Extrinsic` signed?
+	/// If no information are available about signed/unsigned, `None` should be returned.
+	fn is_signed(&self) -> Option<bool> { None }
 }

substrate/core/sr-primitives/src/transaction_validity.rs

@@ -33,11 +33,11 @@ pub type TransactionTag = Vec<u8>;
 #[cfg_attr(feature = "std", derive(Debug))]
 pub enum TransactionValidity {
 	Invalid,
-	Valid(
-		/* priority: */TransactionPriority,
-		/* requires: */Vec<TransactionTag>,
-		/* provides: */Vec<TransactionTag>,
-		/* longevity: */TransactionLongevity
-	),
+	Valid {
+		priority: TransactionPriority,
+		requires: Vec<TransactionTag>,
+		provides: Vec<TransactionTag>,
+		longevity: TransactionLongevity
+	},
 	Unknown,
 }