Offchain Phragmén BREAKING.

bin/node/runtime/src/lib.rs

@@ -439,6 +439,7 @@ impl pallet_sudo::Trait for Runtime {
 type SubmitTransaction = TransactionSubmitter<ImOnlineId, Runtime, UncheckedExtrinsic>;
 
 parameter_types! {
+	// assume 1 slot == 1 block
 	pub const SessionDuration: BlockNumber = EPOCH_DURATION_IN_SLOTS as _;
 }
 

frame/babe/Cargo.toml

@@ -5,7 +5,6 @@ authors = ["Parity Technologies <admin@parity.io>"]
 edition = "2018"
 
 [dependencies]
-hex-literal = "0.2.1"
 codec = { package = "parity-scale-codec", version = "1.0.0", default-features = false, features = ["derive"] }
 serde = { version = "1.0.101", optional = true }
 sp-inherents = { version = "2.0.0", default-features = false, path = "../../primitives/inherents" }
@@ -21,11 +20,8 @@ sp-consensus-babe = { version = "0.8", default-features = false, path = "../../p
 sp-io ={ path = "../../primitives/io", default-features = false }
 
 [dev-dependencies]
-lazy_static = "1.4.0"
-parking_lot = "0.9.0"
 sp-version = { version = "2.0.0", default-features = false, path = "../../primitives/version" }
 sp-core = { version = "2.0.0", path = "../../primitives/core" }
-substrate-test-runtime = { version = "2.0.0", path = "../../test-utils/runtime" }
 
 [features]
 default = ["std"]

frame/babe/src/lib.rs

@@ -26,7 +26,7 @@ use sp_std::{result, prelude::*};
 use frame_support::{decl_storage, decl_module, traits::FindAuthor, traits::Get};
 use sp_timestamp::OnTimestampSet;
 use sp_runtime::{generic::DigestItem, ConsensusEngineId, Perbill};
-use sp_runtime::traits::{IsMember, SaturatedConversion, Saturating, RandomnessBeacon};
+use sp_runtime::traits::{IsMember, SaturatedConversion, Saturating, RandomnessBeacon, One, Bounded};
 use sp_staking::{
 	SessionIndex,
 	offence::{Offence, Kind},
@@ -305,12 +305,31 @@ impl<T: Trait> Module<T> {
 		// epoch 0 as having started at the slot of block 1. We want to use
 		// the same randomness and validator set as signalled in the genesis,
 		// so we don't rotate the epoch.
-		now != sp_runtime::traits::One::one() && {
+		now != One::one() && {
 			let diff = CurrentSlot::get().saturating_sub(Self::current_epoch_start());
 			diff >= T::EpochDuration::get()
 		}
 	}
 
+	/// Return the _best guess_ block number, at which the next epoch change is predicted to happen.
+	///
+	/// In other word, this is only accurate if no slots are missed. Given missed slots, the slot
+	/// number will grow while the block number will not. Hence, the result can be interpreted as an
+	/// upper bound.
+	///
+	/// -------------- IMPORTANT NOTE --------------
+	/// This implementation is linked to how [`should_epoch_change`] is working. This might need to
+	/// be updated accordingly, if the underlying mechanics of slot and epochs change.
+	pub fn next_epoch_change(now: T::BlockNumber) -> T::BlockNumber {
+		let next_slot = Self::current_epoch_start().saturating_add(T::EpochDuration::get());
+		let slots_remaining = next_slot
+			.checked_sub(CurrentSlot::get())
+			.unwrap_or(Bounded::max_value());
+		// This is a best effort guess. Drifts in the slot/block ratio will cause errors here.
+		let blocks_remaining: T::BlockNumber = slots_remaining.saturated_into();
+		now.saturating_add(blocks_remaining)
+	}
+
 	/// DANGEROUS: Enact an epoch change. Should be done on every block where `should_epoch_change` has returned `true`,
 	/// and the caller is the only caller of this function.
 	///
@@ -322,10 +341,7 @@ impl<T: Trait> Module<T> {
 	) {
 		// PRECONDITION: caller has done initialization and is guaranteed
 		// by the session module to be called before this.
-		#[cfg(debug_assertions)]
-		{
-			assert!(Self::initialized().is_some())
-		}
+		debug_assert!(Self::initialized().is_some());
 
 		// Update epoch index
 		let epoch_index = EpochIndex::get()
@@ -471,6 +487,12 @@ impl<T: Trait> OnTimestampSet<T::Moment> for Module<T> {
 	fn on_timestamp_set(_moment: T::Moment) { }
 }
 
+impl<T: Trait> frame_support::traits::PredictNextSessionChange<T::BlockNumber> for Module<T> {
+	fn predict_next_session_change(now: T::BlockNumber) -> T::BlockNumber {
+		Self::next_epoch_change(now)
+	}
+}
+
 impl<T: Trait> sp_runtime::BoundToRuntimeAppPublic for Module<T> {
 	type Public = AuthorityId;
 }

frame/babe/src/mock.rs

@@ -17,13 +17,16 @@
 //! Test utilities
 #![allow(dead_code, unused_imports)]
 
-use super::{Trait, Module, GenesisConfig};
+use codec::Encode;
+use super::{Trait, Module, GenesisConfig, CurrentSlot};
 use sp_consensus_babe::AuthorityId;
 use sp_runtime::{
-	traits::IdentityLookup, Perbill, testing::{Header, UintAuthorityId}, impl_opaque_keys,
+	Perbill, impl_opaque_keys,
+	testing::{Header, UintAuthorityId, Digest, DigestItem},
+	traits::{IdentityLookup, OnInitialize},
 };
 use sp_version::RuntimeVersion;
-use frame_support::{impl_outer_origin, parameter_types, weights::Weight};
+use frame_support::{impl_outer_origin, parameter_types, StorageValue, weights::Weight};
 use sp_io;
 use sp_core::{H256, Blake2Hasher};
 
@@ -45,7 +48,6 @@ parameter_types! {
 	pub const MinimumPeriod: u64 = 1;
 	pub const EpochDuration: u64 = 3;
 	pub const ExpectedBlockTime: u64 = 1;
-	pub const Version: RuntimeVersion = substrate_test_runtime::VERSION;
 	pub const DisabledValidatorsThreshold: Perbill = Perbill::from_percent(16);
 }
 
@@ -55,7 +57,7 @@ impl frame_system::Trait for Test {
 	type BlockNumber = u64;
 	type Call = ();
 	type Hash = H256;
-	type Version = Version;
+	type Version = ();
 	type Hashing = sp_runtime::traits::BlakeTwo256;
 	type AccountId = DummyValidatorId;
 	type Lookup = IdentityLookup<Self::AccountId>;
@@ -78,7 +80,7 @@ impl pallet_session::Trait for Test {
 	type Event = ();
 	type ValidatorId = <Self as frame_system::Trait>::AccountId;
 	type ShouldEndSession = Babe;
-	type SessionHandler = (Babe,Babe,);
+	type SessionHandler = (Babe,);
 	type OnSessionEnding = ();
 	type ValidatorIdOf = ();
 	type SelectInitialValidators = ();
@@ -106,5 +108,42 @@ pub fn new_test_ext(authorities: Vec<DummyValidatorId>) -> sp_io::TestExternalit
 	t.into()
 }
 
+pub fn go_to_block(n: u64, s: u64) {
+	let pre_digest = make_pre_digest(0, s, [1; 32], [0xff; 64]);
+	System::initialize(&n, &Default::default(), &Default::default(), &pre_digest);
+	System::set_block_number(n);
+	if s > 1 {
+		CurrentSlot::put(s);
+	}
+	// includes a call into `Babe::do_initialize`.
+	Session::on_initialize(n);
+}
+
+/// Slots will grow accordingly to blocks
+pub fn progress_to_block(n: u64) {
+	let mut slot = Babe::current_slot() + 1;
+	for i in System::block_number()+1..=n {
+		go_to_block(i, slot);
+		slot += 1;
+	}
+}
+
+pub fn make_pre_digest(
+	authority_index: sp_consensus_babe::AuthorityIndex,
+	slot_number: sp_consensus_babe::SlotNumber,
+	vrf_output: [u8; sp_consensus_babe::VRF_OUTPUT_LENGTH],
+	vrf_proof: [u8; sp_consensus_babe::VRF_PROOF_LENGTH],
+) -> Digest {
+	let digest_data = sp_consensus_babe::RawBabePreDigest::Primary {
+		authority_index,
+		slot_number,
+		vrf_output,
+		vrf_proof,
+	};
+	let log = DigestItem::PreRuntime(sp_consensus_babe::BABE_ENGINE_ID, digest_data.encode());
+	Digest { logs: vec![log] }
+}
+
 pub type System = frame_system::Module<Test>;
 pub type Babe = Module<Test>;
+pub type Session = pallet_session::Module<Test>;

frame/babe/src/tests.rs

@@ -17,8 +17,8 @@
 //! Consensus extension module tests for BABE consensus.
 
 use super::*;
-use mock::{new_test_ext, Babe, Test};
-use sp_runtime::{traits::OnFinalize, testing::{Digest, DigestItem}};
+use mock::*;
+use sp_runtime::{traits::OnFinalize};
 use pallet_session::ShouldEndSession;
 
 const EMPTY_RANDOMNESS: [u8; 32] = [
@@ -28,22 +28,6 @@ const EMPTY_RANDOMNESS: [u8; 32] = [
 	217, 153, 138, 37, 48, 192, 248, 0,
 ];
 
-fn make_pre_digest(
-	authority_index: sp_consensus_babe::AuthorityIndex,
-	slot_number: sp_consensus_babe::SlotNumber,
-	vrf_output: [u8; sp_consensus_babe::VRF_OUTPUT_LENGTH],
-	vrf_proof: [u8; sp_consensus_babe::VRF_PROOF_LENGTH],
-) -> Digest {
-	let digest_data = sp_consensus_babe::RawBabePreDigest::Primary {
-		authority_index,
-		slot_number,
-		vrf_output,
-		vrf_proof,
-	};
-	let log = DigestItem::PreRuntime(sp_consensus_babe::BABE_ENGINE_ID, digest_data.encode());
-	Digest { logs: vec![log] }
-}
-
 #[test]
 fn empty_randomness_is_correct() {
 	let s = compute_randomness([0; RANDOMNESS_LENGTH], 0, std::iter::empty(), None);
@@ -124,3 +108,24 @@ fn authority_index() {
 			"Trivially invalid authorities are ignored")
 	})
 }
+
+#[test]
+fn can_predict_next_epoch_change() {
+	new_test_ext(vec![]).execute_with(|| {
+		assert_eq!(<Test as Trait>::EpochDuration::get(), 3);
+		// this sets the genesis slot to 6;
+		go_to_block(1, 6);
+		assert_eq!(Babe::genesis_slot(), 6);
+		assert_eq!(Babe::current_slot(), 6);
+		assert_eq!(Babe::epoch_index(), 0);
+
+		progress_to_block(5);
+
+		assert_eq!(Babe::epoch_index(), 5 / 3);
+		assert_eq!(Babe::current_slot(), 10);
+
+		// next epoch change will be at
+		assert_eq!(Babe::current_epoch_start(), 9); // next change will be 12, 2 slots from now
+		assert_eq!(Babe::next_epoch_change(System::block_number()), 5 + 2);
+	})
+}