removed some debug printlns

core/consensus/babe/src/lib.rs

@@ -320,7 +320,7 @@ impl<Hash, H, B, C, E, I, Error, SO> SlotWorker<B> for BabeWorker<C, E, I, SO> w
 					return Box::pin(future::ready(Ok(())))
 				}
 			};
-println!("=== Babe.OnSlot: {}", slot_number);
+
 			let inherent_digest = BabePreDigest {
 				vrf_proof,
 				vrf_output: inout.to_output(),
@@ -1076,7 +1076,7 @@ impl<B, E, Block, I, RA, PRA> BlockImport<Block> for BabeBlockImport<B, E, Block
 			&is_descendent_of,
 			&|epoch| epoch.start_slot <= slot_number,
 		).map_err(|e| ConsensusError::from(ConsensusError::ClientImport(e.to_string())))?;
-println!("=== Babe.ImportBlock.slot={} enacted_epoch={:?}", slot_number, enacted_epoch);
+println!("=== ENACTED_EPOCH: {:?}", enacted_epoch);
 		let check_roots = || -> Result<bool, ConsensusError> {
 			// this can only happen when the chain starts, since there's no
 			// epoch change at genesis. afterwards every time we expect an epoch
@@ -1137,16 +1137,21 @@ println!("=== Babe.ImportBlock.slot={} enacted_epoch={:?}", slot_number, enacted
 					enacted_epoch.encode(),
 				);
 
-				let current_epoch = epoch_from_runtime(&*self.api, &BlockId::Hash(parent_hash))
-					.ok_or(consensus_common::Error::InvalidAuthoritiesSet)?;
+				// we really could ignore epoch0 here, because the change epoch0 -> epoch1 doesn't emit any digest
+				// => we'll never reach this code
+				let current_epoch = epoch(&*self.api, &BlockId::Hash(parent_hash))?;
+				let authorities_changed = match current_epoch {
+					MaybeSpanEpoch::Genesis(_, epoch1) => epoch1.authorities != enacted_epoch.authorities,
+					MaybeSpanEpoch::Regular(epoch) => epoch.authorities != enacted_epoch.authorities,
+				};
 
 				// if the authorities have changed then we populate the
 				// `AUTHORITIES` key with the enacted epoch, so that the inner
 				// `ImportBlock` can process it (`EPOCH` is specific to BABE).
 				// e.g. in the case of GRANDPA it would require a justification
 				// for the block, expecting that the authorities actually
 				// changed.
-				if current_epoch.authorities != enacted_epoch.authorities {
+				if authorities_changed {
 					new_cache.insert(
 						well_known_cache_keys::AUTHORITIES,
 						enacted_epoch.authorities.encode(),
@@ -1157,7 +1162,6 @@ println!("=== Babe.ImportBlock.slot={} enacted_epoch={:?}", slot_number, enacted
 			old_epoch_changes = Some(epoch_changes.clone());
 
 			// track the epoch change in the fork tree
-println!("=== Babe.ImportBlock.ImportNextEpoch: {:?}", next_epoch);
 			epoch_changes.import(
 				hash,
 				number,

core/consensus/slots/src/slots.rs

@@ -162,7 +162,7 @@ impl<SC: SlotCompatible + Unpin> Stream for Slots<SC> {
 			// never yield the same slot twice.
 			if slot_num > self.last_slot {
 				self.last_slot = slot_num;
-println!("=== slot_ready: {}", slot_num);
+
 				break Poll::Ready(Some(Ok(SlotInfo {
 					number: slot_num,
 					duration: self.slot_duration,

srml/babe/src/lib.rs

@@ -222,26 +222,11 @@ decl_module! {
 
 		/// Initialization
 		fn on_initialize() {
-println!("=== Babe.OnInitialize");
-			for digest in Self::get_inherent_digests()
-				.logs
-				.iter()
-				.filter_map(|s| s.as_pre_runtime())
-				.filter_map(|(id, mut data)| if id == BABE_ENGINE_ID {
-					RawBabePreDigest::decode(&mut data)
-				} else {
-					None
-				})
-			{
-				if EpochStartSlot::get() == 0 {
-					EpochStartSlot::put(digest.slot_number);
-				}
-println!("=== Babe.OnInitialize: {}", digest.slot_number);
-				CurrentSlot::put(digest.slot_number);
-				Self::deposit_vrf_output(&digest.vrf_output);
-
-				return;
-			}
+			// TODO: this could be safely removed (in current implementation), because:
+			// 1) session.on_initialize is called first
+			// 2) session.on_initialize calls should_end_session
+			// 3) should_end_session calls do_initialize
+			Self::do_initialize();
 		}
 	}
 }
@@ -278,8 +263,10 @@ impl<T: Trait> IsMember<AuthorityId> for Module<T> {
 
 impl<T: Trait> session::ShouldEndSession<T::BlockNumber> for Module<T> {
 	fn should_end_session(_: T::BlockNumber) -> bool {
+		use sr_primitives::traits::OnInitialize;
+		Self::do_initialize();
+
 		let diff = CurrentSlot::get().saturating_sub(EpochStartSlot::get());
-println!("=== Babe.should_end_session: {} - {} = {} >= {}", CurrentSlot::get(), EpochStartSlot::get(), diff, T::EpochDuration::get());
 		diff >= T::EpochDuration::get()
 	}
 }
@@ -305,6 +292,28 @@ impl<T: Trait> Module<T> {
 		UnderConstruction::mutate(|z| z.iter_mut().zip(vrf_output).for_each(|(x, y)| *x^=y))
 	}
 
+	fn do_initialize() {
+		for digest in Self::get_inherent_digests()
+			.logs
+			.iter()
+			.filter_map(|s| s.as_pre_runtime())
+			.filter_map(|(id, mut data)| if id == BABE_ENGINE_ID {
+				RawBabePreDigest::decode(&mut data)
+			} else {
+				None
+			})
+		{
+			if EpochStartSlot::get() == 0 {
+				EpochStartSlot::put(digest.slot_number);
+			}
+
+			CurrentSlot::put(digest.slot_number);
+			Self::deposit_vrf_output(&digest.vrf_output);
+
+			return;
+		}
+	}
+
 	/// Call this function exactly once when an epoch changes, to update the
 	/// randomness. Returns the new randomness.
 	fn randomness_change_epoch(next_epoch_index: u64) -> [u8; RANDOMNESS_LENGTH] {
@@ -330,7 +339,6 @@ impl<T: Trait + staking::Trait> session::OneSessionHandler<T::AccountId> for Mod
 	fn on_new_session<'a, I: 'a>(_changed: bool, validators: I, queued_validators: I)
 		where I: Iterator<Item=(&'a T::AccountId, AuthorityId)>
 	{
-println!("=== Session.OnNewSession");
 		use staking::BalanceOf;
 		let to_votes = |b: BalanceOf<T>| {
 			<T::CurrencyToVote as Convert<BalanceOf<T>, u64>>::convert(b)
@@ -391,7 +399,7 @@ println!("=== Session.OnNewSession");
 			authorities: next_authorities,
 			randomness: next_randomness,
 		};
-println!("=== Session.NextEpochData: {:?}", next);
+
 		Self::deposit_consensus(ConsensusLog::NextEpochData(next))
 	}
 

srml/session/src/lib.rs

@@ -432,7 +432,6 @@ impl<T: Trait> Module<T> {
 	/// equivocation punishment after a fork.
 	pub fn rotate_session() {
 		let session_index = CurrentIndex::get();
-println!("=== Session.RotateSession");
 		let changed = QueuedChanged::get();
 		let mut next_changed = Changed::take();