Refactored out DigestItem::AuthoritiesChanged. Building.

core/consensus/aura/primitives/src/lib.rs

@@ -21,7 +21,7 @@
 use parity_codec::Codec;
 use substrate_client::decl_runtime_apis;
 use substrate_primitives::ed25519;
-use runtime_primitives::ConsensusEngineId;
+use runtime_primitives::{ConsensusEngineId, traits::DigestFor};
 
 /// The `ConsensusEngineId` of AuRa.
 pub const AURA_ENGINE_ID: ConsensusEngineId = [b'a', b'u', b'r', b'a'];
@@ -32,6 +32,10 @@ pub type AuthorityId = ed25519::Public;
 decl_runtime_apis! {
 	/// API necessary for block authorship with aura.
 	pub trait AuraApi<AuthorityId: Codec> {
+		/// Returns the new authorities set, if it changed in this block according to the digest.
+		fn authorities_change(digest: &DigestFor<Block>)
+			-> Option<Vec<AuthorityId>>;
+
 		/// Return the slot duration in seconds for Aura.
 		/// Currently, only the value provided by this type at genesis
 		/// will be used.

core/consensus/aura/src/digest.rs

@@ -40,7 +40,7 @@ pub trait CompatibleDigestItem<T: Pair>: Sized {
 	fn as_aura_pre_digest(&self) -> Option<u64>;
 }
 
-impl<P, Hash> CompatibleDigestItem<P> for DigestItem<Hash, P::Public, P::Signature>
+impl<P, Hash> CompatibleDigestItem<P> for DigestItem<Hash, P::Signature>
 	where P: Pair, P::Signature: Clone + Encode + Decode,
 {
 	fn aura_seal(signature: Signature<P>) -> Self {

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::Public, P::Signature>: DigestItem<Hash=B::Hash>,
+	generic::DigestItem<B::Hash, P::Signature>: 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> + DigestItem<AuthorityId=AuthorityId<P>>,
+	DigestItemFor<B>: CompatibleDigestItem<P>,
 	H: Header<
-		Digest=generic::Digest<generic::DigestItem<B::Hash, P::Public, P::Signature>>,
+		Digest=generic::Digest<generic::DigestItem<B::Hash, P::Signature>>,
 		Hash=B::Hash,
 	>,
 	E: Environment<B, Error=Error>,
@@ -196,15 +196,15 @@ 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::Public, P::Signature>>,
+		Digest=generic::Digest<generic::DigestItem<B::Hash, P::Signature>>,
 		Hash=B::Hash,
 	>,
 	I: BlockImport<B> + Send + Sync + 'static,
 	P: Pair + Send + Sync + 'static,
 	P::Public: Member + Encode + Decode + Hash,
 	P::Signature: Member + Encode + Decode + Hash + Debug,
 	SO: SyncOracle + Send + Clone,
-	DigestItemFor<B>: CompatibleDigestItem<P> + DigestItem<AuthorityId=AuthorityId<P>, Hash=B::Hash>,
+	DigestItemFor<B>: CompatibleDigestItem<P> + DigestItem<Hash=B::Hash>,
 	Error: ::std::error::Error + Send + From<::consensus_common::Error> + From<I::Error> + 'static,
 {
 	type OnSlot = Box<dyn Future<Item=(), Error=consensus_common::Error> + Send>;
@@ -259,7 +259,7 @@ impl<H, B, C, E, I, P, Error, SO> SlotWorker<B> for AuraWorker<C, E, I, P, SO> w
 				);
 
 				// we are the slot author. make a block and sign it.
-				let proposer = match env.init(&chain_head, &authorities) {
+				let proposer = match env.init(&chain_head) {
 					Ok(p) => p,
 					Err(e) => {
 						warn!("Unable to author block in slot {:?}: {:?}", slot_num, e);
@@ -523,7 +523,7 @@ impl<B: Block> ExtraVerification<B> for NothingExtra {
 impl<B: Block, C, E, P> Verifier<B> for AuraVerifier<C, E, P> where
 	C: ProvideRuntimeApi + Send + Sync + client::backend::AuxStore + ProvideCache<B>,
 	C::Api: BlockBuilderApi<B> + AuraApi<B, AuthorityId<P>>,
-	DigestItemFor<B>: CompatibleDigestItem<P> + DigestItem<AuthorityId=AuthorityId<P>>,
+	DigestItemFor<B>: CompatibleDigestItem<P>,
 	E: ExtraVerification<B>,
 	P: Pair + Send + Sync + 'static,
 	P::Public: Send + Sync + Hash + Eq + Clone + Decode + Encode + Debug + AsRef<P::Public> + 'static,
@@ -591,11 +591,12 @@ impl<B: Block, C, E, P> Verifier<B> for AuraVerifier<C, E, P> where
 
 				extra_verification.into_future().wait()?;
 
-				let maybe_keys = pre_header.digest()
+				// TODO: make this work with the Aura-specific authorities change log.
+				let maybe_keys = None;/*pre_header.digest()
 					.log(DigestItem::as_authorities_change)
 					.map(|digest| digest.to_vec())
 					.map(Encode::encode)
-					.map(|blob| vec![(well_known_cache_keys::AUTHORITIES, blob)]);
+					.map(|blob| vec![(well_known_cache_keys::AUTHORITIES, blob)]);*/
 
 				let import_block = ImportBlock {
 					origin,
@@ -703,7 +704,7 @@ pub fn import_queue<B, C, E, P>(
 	B: Block,
 	C: 'static + ProvideRuntimeApi + ProvideCache<B> + Send + Sync + AuxStore,
 	C::Api: BlockBuilderApi<B> + AuraApi<B, AuthorityId<P>>,
-	DigestItemFor<B>: CompatibleDigestItem<P> + DigestItem<AuthorityId=AuthorityId<P>>,
+	DigestItemFor<B>: CompatibleDigestItem<P>,
 	E: 'static + ExtraVerification<B>,
 	P: Pair + Send + Sync + 'static,
 	P::Public: Clone + Eq + Send + Sync + Hash + Debug + Encode + Decode + AsRef<P::Public>,

core/consensus/babe/src/digest.rs

@@ -89,7 +89,7 @@ pub trait CompatibleDigestItem: Sized {
 	fn as_babe_seal(&self) -> Option<Signature>;
 }
 
-impl<Hash: Debug> CompatibleDigestItem for DigestItem<Hash, Public, Vec<u8>>
+impl<Hash: Debug> CompatibleDigestItem for DigestItem<Hash, Vec<u8>>
 {
 	fn babe_pre_digest(digest: BabePreDigest) -> Self {
 		DigestItem::PreRuntime(BABE_ENGINE_ID, digest.encode())
@@ -123,7 +123,7 @@ impl<Hash: Debug> CompatibleDigestItem for DigestItem<Hash, Public, Vec<u8>>
 	}
 }
 
-impl<Hash: Debug> CompatibleDigestItem for DigestItem<Hash, Public, Signature>
+impl<Hash: Debug> CompatibleDigestItem for DigestItem<Hash, Signature>
 {
 	fn babe_pre_digest(digest: BabePreDigest) -> Self {
 		DigestItem::PreRuntime(BABE_ENGINE_ID, digest.encode())
@@ -146,4 +146,4 @@ impl<Hash: Debug> CompatibleDigestItem for DigestItem<Hash, Public, Signature>
 			_ => None,
 		}
 	}
-}
+}

core/consensus/babe/src/lib.rs

@@ -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, Public, Signature>: DigestItem<Hash=B::Hash>,
+	generic::DigestItem<B::Hash, Signature>: DigestItem<Hash=B::Hash>,
 	E::Proposer: Proposer<B, Error=Error>,
 	<<E::Proposer as Proposer<B>>::Create as IntoFuture>::Future: Send + 'static,
-	DigestItemFor<B>: CompatibleDigestItem + DigestItem<AuthorityId=Public>,
+	DigestItemFor<B>: CompatibleDigestItem,
 	H: Header<
-		Digest=generic::Digest<generic::DigestItem<B::Hash, Public, Signature>>,
+		Digest=generic::Digest<generic::DigestItem<B::Hash, Signature>>,
 		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, Public, Signature>>,
+		Digest=generic::Digest<generic::DigestItem<B::Hash, Signature>>,
 		Hash=B::Hash,
 	>,
 	I: BlockImport<B> + Send + Sync + 'static,
@@ -304,7 +304,7 @@ impl<Hash, H, B, C, E, I, Error, SO> SlotWorker<B> for BabeWorker<C, E, I, SO> w
 			);
 
 			// we are the slot author. make a block and sign it.
-			let proposer = match env.init(&chain_head, &authorities) {
+			let proposer = match env.init(&chain_head) {
 				Ok(p) => p,
 				Err(e) => {
 					warn!(target: "babe", "Unable to author block in slot {:?}: {:?}", slot_num, e);
@@ -568,7 +568,7 @@ impl<B: Block> ExtraVerification<B> for NothingExtra {
 impl<B: Block, C, E> Verifier<B> for BabeVerifier<C, E> where
 	C: ProvideRuntimeApi + Send + Sync + AuxStore + ProvideCache<B>,
 	C::Api: BlockBuilderApi<B> + BabeApi<B, Public>,
-	DigestItemFor<B>: CompatibleDigestItem + DigestItem<AuthorityId=Public>,
+	DigestItemFor<B>: CompatibleDigestItem,// + DigestItem<AuthorityId=Public>,
 	E: ExtraVerification<B>,
 {
 	fn verify(
@@ -645,11 +645,14 @@ impl<B: Block, C, E> Verifier<B> for BabeVerifier<C, E> where
 
 				extra_verification.into_future().wait()?;
 
-				let maybe_keys = pre_header.digest()
+				let maybe_keys = None;
+				/* TODO: make this work:
+					pre_header.digest()
 					.log(DigestItem::as_authorities_change)
 					.map(|digest| digest.to_vec())
 					.map(Encode::encode)
 					.map(|blob| vec![(well_known_cache_keys::AUTHORITIES, blob)]);
+				*/
 
 				let import_block = ImportBlock {
 					origin,

core/network/src/test/mod.rs

@@ -37,7 +37,7 @@ use consensus::import_queue::{
 	Link, SharedBlockImport, SharedJustificationImport, Verifier, SharedFinalityProofImport,
 	SharedFinalityProofRequestBuilder,
 };
-use consensus::{Error as ConsensusError};
+use consensus::{Error as ConsensusError, well_known_cache_keys::Id as CacheKeyId};
 use consensus::{BlockOrigin, ForkChoiceStrategy, ImportBlock, JustificationImport};
 use crate::consensus_gossip::{ConsensusGossip, MessageRecipient as GossipMessageRecipient, TopicNotification};
 use futures::{prelude::*, sync::{mpsc, oneshot}};
@@ -47,7 +47,7 @@ use parking_lot::{Mutex, RwLock};
 use primitives::{H256, Blake2Hasher};
 use crate::protocol::{Context, Protocol, ProtocolConfig, ProtocolStatus, CustomMessageOutcome, NetworkOut};
 use runtime_primitives::generic::BlockId;
-use runtime_primitives::traits::{Block as BlockT, Digest, DigestItem, Header, NumberFor};
+use runtime_primitives::traits::{Block as BlockT, Digest, Header, NumberFor};
 use runtime_primitives::{Justification, ConsensusEngineId};
 use crate::service::{NetworkLink, NetworkMsg, ProtocolMsg, TransactionPool};
 use crate::specialization::NetworkSpecialization;
@@ -73,9 +73,12 @@ impl<B: BlockT> Verifier<B> for PassThroughVerifier {
 		header: B::Header,
 		justification: Option<Justification>,
 		body: Option<Vec<B::Extrinsic>>
-	) -> Result<(ImportBlock<B>, Option<Vec<AuthorityId>>), String> {
-		let new_authorities = header.digest().log(DigestItem::as_authorities_change)
-			.map(|auth| auth.iter().cloned().collect());
+	) -> Result<(ImportBlock<B>, Option<Vec<(CacheKeyId, Vec<u8>)>>), String> {
+/*		let new_authorities = header.digest().log(DigestItem::as_authorities_change)
+			.map(|auth| auth.iter().cloned().collect());*/
+		// TODO: should grab the new authorities from the digest (if any) and put in the new cache
+		// key that the consensus algo expects.
+		let maybe_keys = None;
 
 		Ok((ImportBlock {
 			origin,
@@ -86,7 +89,7 @@ impl<B: BlockT> Verifier<B> for PassThroughVerifier {
 			post_digests: vec![],
 			auxiliary: Vec::new(),
 			fork_choice: ForkChoiceStrategy::LongestChain,
-		}, new_authorities))
+		}, maybe_keys))
 	}
 }
 

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

@@ -62,10 +62,7 @@ impl<Item> traits::Digest for Digest<Item> where
 /// provide opaque access to other items.
 #[derive(PartialEq, Eq, Clone)]
 #[cfg_attr(feature = "std", derive(Debug))]
-pub enum DigestItem<Hash, AuthorityId, SealSignature> {
-	/// System digest item announcing that authorities set has been changed
-	/// in the block. Contains the new set of authorities.
-	AuthoritiesChange(Vec<AuthorityId>),
+pub enum DigestItem<Hash, SealSignature> {
 	/// 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.
@@ -89,7 +86,7 @@ pub enum DigestItem<Hash, AuthorityId, SealSignature> {
 }
 
 #[cfg(feature = "std")]
-impl<Hash: Encode, AuthorityId: Encode, SealSignature: Encode> ::serde::Serialize for DigestItem<Hash, AuthorityId, SealSignature> {
+impl<Hash: Encode, SealSignature: Encode> ::serde::Serialize for DigestItem<Hash, SealSignature> {
 	fn serialize<S>(&self, seq: S) -> Result<S::Ok, S::Error> where S: ::serde::Serializer {
 		self.using_encoded(|bytes| {
 			::substrate_primitives::bytes::serialize(bytes, seq)
@@ -102,9 +99,7 @@ impl<Hash: Encode, AuthorityId: Encode, SealSignature: Encode> ::serde::Serializ
 /// final runtime implementations for encoding/decoding its log items.
 #[derive(PartialEq, Eq, Clone)]
 #[cfg_attr(feature = "std", derive(Debug))]
-pub enum DigestItemRef<'a, Hash: 'a, AuthorityId: 'a, SealSignature: 'a> {
-	/// Reference to `DigestItem::AuthoritiesChange`.
-	AuthoritiesChange(&'a [AuthorityId]),
+pub enum DigestItemRef<'a, Hash: 'a, SealSignature: 'a> {
 	/// Reference to `DigestItem::ChangesTrieRoot`.
 	ChangesTrieRoot(&'a Hash),
 	/// A message from the runtime to the consensus engine. This should *never*
@@ -133,14 +128,13 @@ pub enum DigestItemRef<'a, Hash: 'a, AuthorityId: 'a, SealSignature: 'a> {
 #[derive(Encode, Decode)]
 enum DigestItemType {
 	Other = 0,
-	AuthoritiesChange = 1,
 	ChangesTrieRoot = 2,
 	Consensus = 4,
 	Seal = 5,
 	PreRuntime = 6,
 }
 
-impl<Hash, AuthorityId, SealSignature> DigestItem<Hash, AuthorityId, SealSignature> {
+impl<Hash, SealSignature> DigestItem<Hash, SealSignature> {
 	/// Returns Some if `self` is a `DigestItem::Other`.
 	pub fn as_other(&self) -> Option<&Vec<u8>> {
 		match *self {
@@ -150,9 +144,8 @@ impl<Hash, AuthorityId, SealSignature> DigestItem<Hash, AuthorityId, SealSignatu
 	}
 
 	/// Returns a 'referencing view' for this digest item.
-	fn dref<'a>(&'a self) -> DigestItemRef<'a, Hash, AuthorityId, SealSignature> {
+	fn dref<'a>(&'a self) -> DigestItemRef<'a, Hash, SealSignature> {
 		match *self {
-			DigestItem::AuthoritiesChange(ref v) => DigestItemRef::AuthoritiesChange(v),
 			DigestItem::ChangesTrieRoot(ref v) => DigestItemRef::ChangesTrieRoot(v),
 			DigestItem::Consensus(ref v, ref s) => DigestItemRef::Consensus(v, s),
 			DigestItem::Seal(ref v, ref s) => DigestItemRef::Seal(v, s),
@@ -164,16 +157,10 @@ impl<Hash, AuthorityId, SealSignature> DigestItem<Hash, AuthorityId, SealSignatu
 
 impl<
 	Hash: Codec + Member,
-	AuthorityId: Codec + Member + MaybeHash,
 	SealSignature: Codec + Member,
-> traits::DigestItem for DigestItem<Hash, AuthorityId, SealSignature> {
+> traits::DigestItem for DigestItem<Hash, SealSignature> {
 	type Hash = Hash;
-/*	type AuthorityId = AuthorityId;
 
-	fn as_authorities_change(&self) -> Option<&[Self::AuthorityId]> {
-		self.dref().as_authorities_change()
-	}
-*/
 	fn as_changes_trie_root(&self) -> Option<&Self::Hash> {
 		self.dref().as_changes_trie_root()
 	}
@@ -183,20 +170,17 @@ impl<
 	}
 }
 
-impl<Hash: Encode, AuthorityId: Encode, SealSignature: Encode> Encode for DigestItem<Hash, AuthorityId, SealSignature> {
+impl<Hash: Encode, SealSignature: Encode> Encode for DigestItem<Hash, SealSignature> {
 	fn encode(&self) -> Vec<u8> {
 		self.dref().encode()
 	}
 }
 
-impl<Hash: Decode, AuthorityId: Decode, SealSignature: Decode> Decode for DigestItem<Hash, AuthorityId, SealSignature> {
+impl<Hash: Decode, SealSignature: Decode> Decode for DigestItem<Hash, SealSignature> {
 	#[allow(deprecated)]
 	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::ChangesTrieRoot => Some(DigestItem::ChangesTrieRoot(
 				Decode::decode(input)?,
 			)),
@@ -219,15 +203,7 @@ impl<Hash: Decode, AuthorityId: Decode, SealSignature: Decode> Decode for Digest
 	}
 }
 
-impl<'a, Hash: Codec + Member, AuthorityId: Codec + Member, SealSignature: Codec + Member> DigestItemRef<'a, Hash, AuthorityId, SealSignature> {
-	/// Cast this digest item into `AuthoritiesChange`.
-	pub fn as_authorities_change(&self) -> Option<&'a [AuthorityId]> {
-		match *self {
-			DigestItemRef::AuthoritiesChange(ref authorities) => Some(authorities),
-			_ => None,
-		}
-	}
-
+impl<'a, Hash: Codec + Member, SealSignature: Codec + Member> DigestItemRef<'a, Hash, SealSignature> {
 	/// Cast this digest item into `ChangesTrieRoot`.
 	pub fn as_changes_trie_root(&self) -> Option<&'a Hash> {
 		match *self {
@@ -245,15 +221,11 @@ impl<'a, Hash: Codec + Member, AuthorityId: Codec + Member, SealSignature: Codec
 	}
 }
 
-impl<'a, Hash: Encode, AuthorityId: Encode, SealSignature: Encode> Encode for DigestItemRef<'a, Hash, AuthorityId, SealSignature> {
+impl<'a, Hash: Encode, SealSignature: Encode> Encode for DigestItemRef<'a, Hash, SealSignature> {
 	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::ChangesTrieRoot(changes_trie_root) => {
 				DigestItemType::ChangesTrieRoot.encode_to(&mut v);
 				changes_trie_root.encode_to(&mut v);
@@ -289,7 +261,6 @@ mod tests {
 	fn should_serialize_digest() {
 		let digest = Digest {
 			logs: vec![
-				DigestItem::AuthoritiesChange(vec![1]),
 				DigestItem::ChangesTrieRoot(4),
 				DigestItem::Other(vec![1, 2, 3]),
 				DigestItem::Seal(Default::default(), Signature::default())
@@ -298,7 +269,7 @@ mod tests {
 
 		assert_eq!(
 			::serde_json::to_string(&digest).unwrap(),
-			"{\"logs\":[\"0x010401000000\",\"0x0204000000\",\"0x000c010203\",\"0x050000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\"]}",
+			"{\"logs\":[\"0x010401000000\",\"0x000c010203\",\"0x050000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\"]}",
 		);
 	}
 }

core/sr-primitives/src/lib.rs

@@ -737,11 +737,6 @@ macro_rules! impl_outer_log {
 
 		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())