Merge remote-tracking branch 'origin/master' into gav-new-sessions

core/consensus/aura/src/digest.rs

@@ -18,20 +18,24 @@
 //!
 //! This implements the digests for AuRa, to allow the private
 //! `CompatibleDigestItem` trait to appear in public interfaces.
+
 use primitives::Pair;
 use aura_primitives::AURA_ENGINE_ID;
-use runtime_primitives::generic::DigestItem;
-use parity_codec::{Encode, Decode};
+use runtime_primitives::{
+	traits::DigestItem as DigestItemT, generic::{DigestItem, OpaqueDigestItemId}
+};
+use parity_codec::{Encode, Codec};
+use std::fmt::Debug;
 
 type Signature<P> = <P as Pair>::Signature;
 
 /// A digest item which is usable with aura consensus.
-pub trait CompatibleDigestItem<T: Pair>: Sized {
+pub trait CompatibleDigestItem<P: Pair>: Sized {
 	/// Construct a digest item which contains a signature on the hash.
-	fn aura_seal(signature: Signature<T>) -> Self;
+	fn aura_seal(signature: Signature<P>) -> Self;
 
 	/// If this item is an Aura seal, return the signature.
-	fn as_aura_seal(&self) -> Option<&Signature<T>>;
+	fn as_aura_seal(&self) -> Option<Signature<P>>;
 
 	/// Construct a digest item which contains the slot number
 	fn aura_pre_digest(slot_num: u64) -> Self;
@@ -40,28 +44,24 @@ pub trait CompatibleDigestItem<T: Pair>: Sized {
 	fn as_aura_pre_digest(&self) -> Option<u64>;
 }
 
-impl<P, Hash> CompatibleDigestItem<P> for DigestItem<Hash, P::Signature>
-	where P: Pair, P::Signature: Clone + Encode + Decode,
+impl<P, Hash> CompatibleDigestItem<P> for DigestItem<Hash> where
+	P: Pair,
+	Signature<P>: Codec,
+	Hash: Debug + Send + Sync + Eq + Clone + Codec + 'static
 {
 	fn aura_seal(signature: Signature<P>) -> Self {
-		DigestItem::Seal(AURA_ENGINE_ID, signature)
+		DigestItem::Seal(AURA_ENGINE_ID, signature.encode())
 	}
 
-	fn as_aura_seal(&self) -> Option<&Signature<P>> {
-		match self {
-			DigestItem::Seal(AURA_ENGINE_ID, ref sig) => Some(sig),
-			_ => None,
-		}
+	fn as_aura_seal(&self) -> Option<Signature<P>> {
+		self.try_into(OpaqueDigestItemId::Seal(&AURA_ENGINE_ID))
 	}
 
 	fn aura_pre_digest(slot_num: u64) -> Self {
 		DigestItem::PreRuntime(AURA_ENGINE_ID, slot_num.encode())
 	}
 
 	fn as_aura_pre_digest(&self) -> Option<u64> {
-		match self {
-			DigestItem::PreRuntime(AURA_ENGINE_ID, ref buffer) => Decode::decode(&mut &buffer[..]),
-			_ => None,
-		}
+		self.try_into(OpaqueDigestItemId::PreRuntime(&AURA_ENGINE_ID))
 	}
 }

core/consensus/aura/src/lib.rs

@@ -142,15 +142,15 @@ pub fn start_aura<B, C, SC, E, I, P, SO, Error, H>(
 	C: ProvideRuntimeApi + ProvideCache<B> + AuxStore + Send + Sync,
 	C::Api: AuraApi<B, AuthorityId<P>>,
 	SC: SelectChain<B>,
-	generic::DigestItem<B::Hash, P::Signature>: DigestItem<Hash=B::Hash>,
+	generic::DigestItem<B::Hash>: DigestItem<Hash=B::Hash>,
 	E::Proposer: Proposer<B, Error=Error>,
 	<<E::Proposer as Proposer<B>>::Create as IntoFuture>::Future: Send + 'static,
 	P: Pair + Send + Sync + 'static,
 	P::Public: Hash + Member + Encode + Decode,
 	P::Signature: Hash + Member + Encode + Decode,
 	DigestItemFor<B>: CompatibleDigestItem<P>,
 	H: Header<
-		Digest=generic::Digest<generic::DigestItem<B::Hash, P::Signature>>,
+		Digest=generic::Digest<generic::DigestItem<B::Hash>>,
 		Hash=B::Hash,
 	>,
 	E: Environment<B, Error=Error>,
@@ -196,7 +196,7 @@ impl<H, B, C, E, I, P, Error, SO> SlotWorker<B> for AuraWorker<C, E, I, P, SO> w
 	E::Proposer: Proposer<B, Error=Error>,
 	<<E::Proposer as Proposer<B>>::Create as IntoFuture>::Future: Send + 'static,
 	H: Header<
-		Digest=generic::Digest<generic::DigestItem<B::Hash, P::Signature>>,
+		Digest=generic::Digest<generic::DigestItem<B::Hash>>,
 		Hash=B::Hash,
 	>,
 	I: BlockImport<B> + Send + Sync + 'static,

core/consensus/babe/src/digest.rs

@@ -15,12 +15,14 @@
 // along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
 
 //! Private mplementation details of BABE digests.
+
 use primitives::sr25519::{Public, Signature};
 use babe_primitives::BABE_ENGINE_ID;
-use runtime_primitives::generic::DigestItem;
+use runtime_primitives::{
+	traits::DigestItem as DigestItemT, generic::{DigestItem, OpaqueDigestItemId}
+};
 use std::fmt::Debug;
-use parity_codec::{Decode, Encode, Input};
-use log::info;
+use parity_codec::{Decode, Encode, Codec, Input};
 use schnorrkel::{
 	vrf::{VRFProof, VRFOutput, VRF_OUTPUT_LENGTH, VRF_PROOF_LENGTH},
 	PUBLIC_KEY_LENGTH,
@@ -89,61 +91,22 @@ pub trait CompatibleDigestItem: Sized {
 	fn as_babe_seal(&self) -> Option<Signature>;
 }
 
-impl<Hash: Debug> CompatibleDigestItem for DigestItem<Hash, Vec<u8>>
+impl<Hash> CompatibleDigestItem for DigestItem<Hash> where
+	Hash: Debug + Send + Sync + Eq + Clone + Codec + 'static
 {
 	fn babe_pre_digest(digest: BabePreDigest) -> Self {
 		DigestItem::PreRuntime(BABE_ENGINE_ID, digest.encode())
 	}
 
 	fn as_babe_pre_digest(&self) -> Option<BabePreDigest> {
-		match self {
-			DigestItem::PreRuntime(BABE_ENGINE_ID, seal) => {
-				let decoded = Decode::decode(&mut &seal[..]);
-				if decoded.is_none() {
-					info!(target: "babe", "Failed to decode {:?}", seal)
-				}
-				decoded
-			}
-			_ => {
-				info!(target: "babe", "Invalid consensus: {:?}!", self);
-				None
-			}
-		}
+		self.try_into(OpaqueDigestItemId::PreRuntime(&BABE_ENGINE_ID))
 	}
 
 	fn babe_seal(signature: Signature) -> Self {
 		DigestItem::Seal(BABE_ENGINE_ID, signature.encode())
 	}
 
 	fn as_babe_seal(&self) -> Option<Signature> {
-		match self {
-			DigestItem::Seal(BABE_ENGINE_ID, signature) => Decode::decode(&mut &signature[..]),
-			_ => None,
-		}
-	}
-}
-
-impl<Hash: Debug> CompatibleDigestItem for DigestItem<Hash, Signature>
-{
-	fn babe_pre_digest(digest: BabePreDigest) -> Self {
-		DigestItem::PreRuntime(BABE_ENGINE_ID, digest.encode())
-	}
-
-	fn as_babe_pre_digest(&self) -> Option<BabePreDigest> {
-		match self {
-			DigestItem::PreRuntime(BABE_ENGINE_ID, seal) => Decode::decode(&mut &seal[..]),
-			_ => None,
-		}
-	}
-
-	fn babe_seal(signature: Signature) -> Self {
-		DigestItem::Seal(BABE_ENGINE_ID, signature)
-	}
-
-	fn as_babe_seal(&self) -> Option<Signature> {
-		match self {
-			DigestItem::Seal(BABE_ENGINE_ID, signature) => Some(signature.clone()),
-			_ => None,
-		}
+		self.try_into(OpaqueDigestItemId::Seal(&BABE_ENGINE_ID))
 	}
 }

core/consensus/babe/src/lib.rs

@@ -42,7 +42,7 @@ use runtime_support::serde::{Serialize, Deserialize};
 use parity_codec::{Decode, Encode};
 use primitives::{
 	crypto::Pair,
-	sr25519::{Public, Signature, self},
+	sr25519::{Public, self},
 };
 use merlin::Transcript;
 use inherents::{InherentDataProviders, InherentData};
@@ -183,12 +183,12 @@ pub fn start_babe<B, C, SC, E, I, SO, Error, H>(BabeParams {
 	C: ProvideRuntimeApi + ProvideCache<B>,
 	C::Api: BabeApi<B, Public>,
 	SC: SelectChain<B>,
-	generic::DigestItem<B::Hash, Signature>: DigestItem<Hash=B::Hash>,
+	generic::DigestItem<B::Hash>: DigestItem<Hash=B::Hash>,
 	E::Proposer: Proposer<B, Error=Error>,
 	<<E::Proposer as Proposer<B>>::Create as IntoFuture>::Future: Send + 'static,
 	DigestItemFor<B>: CompatibleDigestItem,
 	H: Header<
-		Digest=generic::Digest<generic::DigestItem<B::Hash, Signature>>,
+		Digest=generic::Digest<generic::DigestItem<B::Hash>>,
 		Hash=B::Hash,
 	>,
 	E: Environment<B, Error=Error>,
@@ -236,7 +236,7 @@ impl<Hash, H, B, C, E, I, Error, SO> SlotWorker<B> for BabeWorker<C, E, I, SO> w
 		for<'de> Deserialize<'de> + Debug + Default + AsRef<[u8]> + AsMut<[u8]> +
 		std::hash::Hash + Display + Send + Sync + 'static,
 	H: Header<
-		Digest=generic::Digest<generic::DigestItem<B::Hash, Signature>>,
+		Digest=generic::Digest<generic::DigestItem<B::Hash>>,
 		Hash=B::Hash,
 	>,
 	I: BlockImport<B> + Send + Sync + 'static,

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

@@ -58,6 +58,7 @@ impl<Item> traits::Digest for Digest<Item> where
 	}
 }
 
+/*
 /// Digest item that is able to encode/decode 'system' digest items and
 /// provide opaque access to other items.
 #[derive(PartialEq, Eq, Clone)]
@@ -88,6 +89,153 @@ pub enum DigestItem<Hash> {
 	/// Any 'non-system' digest item, opaque to the native code.
 	Other(Vec<u8>),
 }
+*/
+
+// Macro black magic.
+macro_rules! gen_digest_type {
+	(
+		$( #[doc = $main_docs:tt] )*
+		pub enum $main:ident $(<$($main_params: tt),+>)? { }
+		$(
+			$( #[doc = $doc_attr:tt] )*
+			pub enum $n:ident $(<$($t: tt),+>)? {
+				$(
+					$( #[doc = $variant_doc:tt] )*
+					$variant:ident(($($interior: ty),*), $q: tt),
+				)*
+			}
+		)+
+	) => {
+		$( #[doc = $main_docs] )*
+		#[derive(PartialEq, Eq, Clone)]
+		#[cfg_attr(feature = "std", derive(Debug))]
+		pub enum $main $(<$($main_params),+>)? {
+			$(
+				$(
+					$( #[doc = $variant_doc] )*
+					$variant($($interior),*),
+				)*
+			)*
+		}
+
+		gen_digest_type! {
+			@internal
+			$main : $main $(<$($main_params),+>)? => $(
+				$( #[doc = $doc_attr] )*
+				pub enum $n $(<$($t),+>)? {
+					$(
+						$( #[doc = $variant_doc] )*
+						$variant(($($interior),*), $q),
+					)*
+				}
+			)+
+		}
+	};
+	(
+		@internal
+		$main_id:tt : $main:ty => $(
+			$( #[doc = $doc_attr:tt] )*
+			pub enum $n:ident $(<$($t: tt),+>)? {
+				$(
+					$( #[doc = $variant_doc:tt] )*
+					$variant:ident(($($interior: ty),*), $q: tt),
+				)*
+			}
+		)+
+	) => {
+		$(
+			$( #[doc = $doc_attr] )*
+			#[derive(PartialEq, Eq, Clone)]
+			#[cfg_attr(feature = "std", derive(Debug))]
+			pub enum $n $(<$($t),+>)? {
+				$(
+					$( #[doc = $variant_doc] )*
+					$variant($($interior),*),
+				)*
+			}
+
+			impl<Hash> From<$n $(<$($t),*>)?>
+				for $main {
+				fn from(digest: $n $(<$($t),+>)?) -> Self {
+					match digest {
+						$(
+							$n::$variant $q => $main_id::$variant $q,
+						)*
+					}
+				}
+			}
+		)*
+	};
+}
+
+gen_digest_type! {
+	/// Digest item that is able to encode/decode 'system' digest items and
+	/// provide opaque access to other items.
+	///
+	/// For all variants that include a `ConsensusEngineId`, consensus engine
+	/// implementations **MUST** ignore digests that have a `ConsensusEngineId`
+	/// that is not theirs.  Node implementations **MUST** reject digests that
+	/// have a `ConsensusEngineId` that corresponds to a consensus engine not in
+	/// use.  Node implementations **MUST** reject blocks as malformed if they
+	/// reject any of the block’s digest.  If the runtime supports this, the
+	/// node that issued the block **SHOULD** be reported as having committed
+	/// severe misbehavior and punished accordingly.  The invalid block, or its
+	/// hash, **SHOULD** constitute adequate proof of such misbehavior.
+	pub enum DigestItem<Hash> {}
+
+	/// A digest item that can be produced by consensus engines. Consensus
+	/// engine implementations **MUST NOT** push digests not in this variant.
+	/// This **SHOULD** be detected at compile time. If it is not, the behavior
+	/// of the blockchain is undefined.
+	pub enum ConsensusDigest {
+		/// An inherent digest.
+		///
+		/// These are messages from the consensus engine to the runtime,
+		/// although the consensus engine can (and should) read them itself to
+		/// avoid code and state duplication. It is erroneous for a runtime to
+		/// produce these, but this is checked at compile time. Runtimes can
+		/// (and should) trust these, as with any other inherent. Consensus
+		/// engines MUST verify them.
+		PreRuntime((ConsensusEngineId, Vec<u8>), (a, b)),
+
+		/// Put a Seal on it. This **MUST** come after all other `DigestItem`
+		/// variants. There **MUST** be exactly one `Seal` per consensus engine,
+		/// and its `ConsensusEngineId` **MUST** be that of the consensus engine
+		/// that produced it. Runtimes will not see this variant.
+		Seal((ConsensusEngineId, Vec<u8>), (a, b)),
+	}
+
+	/// A digest item that can be produced by runtimes. Runtime mplementations
+	/// **MUST NOT** push digests not in this variant. This **SHOULD** be
+	/// detected at compile time.  If it is not, the behavior of the blockchain
+	/// is undefined.
+	pub enum RuntimeDigest {
+		/// A message from the runtime to the consensus engine. This MUST NOT be
+		/// generated by the native code of any consensus engine, but this is
+		/// caught at compile time. The `ConsensusEngineId` is that of the
+		/// consensus engine for which this digest is intended. Consensus
+		/// engines MUST ignore digests with `ConsensusEngineId`s other than
+		/// their own.
+		Consensus((ConsensusEngineId, Vec<u8>), (a, b)),
+
+		/// Any 'non-system' digest item, opaque to the native code.  Runtimes
+		/// MUST verify these, and reject any they did not produce.  These MUST
+		/// NOT be produced by native code.
+		Other((Vec<u8>), (a)),
+	}
+
+	/// A digest item that is reserved for the SRML. Only the SRML is allowed to
+	/// push these digests. Consensus engines and third-party runtime code
+	/// **MUST NOT** push digests in this variant. This **SHOULD** be detected
+	/// at compile time. If it is not, the behavior of the blockchain is
+	/// undefined.
+	pub enum SystemDigest<Hash> {
+		/// System digest item that contains the root of changes trie at given
+		/// block. It is created for every block iff runtime supports changes
+		/// trie creation.
+		ChangesTrieRoot((Hash), (a)),
+	}
+}
 
 #[cfg(feature = "std")]
 impl<Hash: Encode> ::serde::Serialize for DigestItem<Hash> {

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

@@ -36,7 +36,9 @@ pub use self::era::{Era, Phase};
 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, OpaqueDigestItemId};
+pub use self::digest::{
+	Digest, DigestItem, DigestItemRef, ConsensusDigest, RuntimeDigest, SystemDigest, OpaqueDigestItemId
+};
 
 use crate::codec::Encode;
 use rstd::prelude::*;