Reorganising the repository - external renames and moves (#4074)

* Adding first rough ouline of the repository structure * Remove old CI stuff * add title * formatting fixes * move node-exits job's script to scripts dir * Move docs into subdir * move to bin * move maintainence scripts, configs and helpers into its own dir * add .local to ignore * move core->client * start up 'test' area * move test client * move test runtime * make test move compile * Add dependencies rule enforcement. * Fix indexing. * Update docs to reflect latest changes * Moving /srml->/paint * update docs * move client/sr-* -> primitives/ * clean old readme * remove old broken code in rhd * update lock * Step 1. * starting to untangle client * Fix after merge. * start splitting out client interfaces * move children and blockchain interfaces * Move trie and state-machine to primitives. * Fix WASM builds. * fixing broken imports * more interface moves * move backend and light to interfaces * move CallExecutor * move cli off client * moving around more interfaces * re-add consensus crates into the mix * fix subkey path * relieve client from executor * starting to pull out client from grandpa * move is_decendent_of out of client * grandpa still depends on client directly * lemme tests pass * rename srml->paint * Make it compile. * rename interfaces->client-api * Move keyring to primitives. * fixup libp2p dep * fix broken use * allow dependency enforcement to fail * move fork-tree * Moving wasm-builder * make env * move build-script-utils * fixup broken crate depdencies and names * fix imports for authority discovery * fix typo * update cargo.lock * fixing imports * Fix paths and add missing crates * re-add missing crates
2026-06-14 16:51:03 +00:00 · 2019-11-14 21:51:17 +01:00
parent becc3b0a4f
commit 60e5011c72
809 changed files with 7801 additions and 6464 deletions
@@ -0,0 +1,265 @@
+// Copyright 2019 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Substrate is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Schema for slots in the aux-db.
+
+use codec::{Encode, Decode};
+use client_api::backend::AuxStore;
+use client_api::error::{Result as ClientResult, Error as ClientError};
+use sr_primitives::traits::Header;
+
+const SLOT_HEADER_MAP_KEY: &[u8] = b"slot_header_map";
+const SLOT_HEADER_START: &[u8] = b"slot_header_start";
+
+/// We keep at least this number of slots in database.
+pub const MAX_SLOT_CAPACITY: u64 = 1000;
+/// We prune slots when they reach this number.
+pub const PRUNING_BOUND: u64 = 2 * MAX_SLOT_CAPACITY;
+
+fn load_decode<C, T>(backend: &C, key: &[u8]) -> ClientResult<Option<T>>
+	where
+		C: AuxStore,
+		T: Decode,
+{
+	match backend.get_aux(key)? {
+		None => Ok(None),
+		Some(t) => T::decode(&mut &t[..])
+			.map_err(
+				|e| ClientError::Backend(format!("Slots DB is corrupted. Decode error: {}", e.what())),
+			)
+			.map(Some)
+	}
+}
+
+/// Represents an equivocation proof.
+#[derive(Debug, Clone)]
+pub struct EquivocationProof<H> {
+	slot: u64,
+	fst_header: H,
+	snd_header: H,
+}
+
+impl<H> EquivocationProof<H> {
+	/// Get the slot number where the equivocation happened.
+	pub fn slot(&self) -> u64 {
+		self.slot
+	}
+
+	/// Get the first header involved in the equivocation.
+	pub fn fst_header(&self) -> &H {
+		&self.fst_header
+	}
+
+	/// Get the second header involved in the equivocation.
+	pub fn snd_header(&self) -> &H {
+		&self.snd_header
+	}
+}
+
+/// Checks if the header is an equivocation and returns the proof in that case.
+///
+/// Note: it detects equivocations only when slot_now - slot <= MAX_SLOT_CAPACITY.
+pub fn check_equivocation<C, H, P>(
+	backend: &C,
+	slot_now: u64,
+	slot: u64,
+	header: &H,
+	signer: &P,
+) -> ClientResult<Option<EquivocationProof<H>>>
+	where
+		H: Header,
+		C: AuxStore,
+		P: Clone + Encode + Decode + PartialEq,
+{
+	// We don't check equivocations for old headers out of our capacity.
+	if slot_now - slot > MAX_SLOT_CAPACITY {
+		return Ok(None)
+	}
+
+	// Key for this slot.
+	let mut curr_slot_key = SLOT_HEADER_MAP_KEY.to_vec();
+	slot.using_encoded(|s| curr_slot_key.extend(s));
+
+	// Get headers of this slot.
+	let mut headers_with_sig = load_decode::<_, Vec<(H, P)>>(backend, &curr_slot_key[..])?
+		.unwrap_or_else(Vec::new);
+
+	// Get first slot saved.
+	let slot_header_start = SLOT_HEADER_START.to_vec();
+	let first_saved_slot = load_decode::<_, u64>(backend, &slot_header_start[..])?
+		.unwrap_or(slot);
+
+	for (prev_header, prev_signer) in headers_with_sig.iter() {
+		// A proof of equivocation consists of two headers:
+		// 1) signed by the same voter,
+		if prev_signer == signer {
+			// 2) with different hash
+			if header.hash() != prev_header.hash() {
+				return Ok(Some(EquivocationProof {
+					slot, // 3) and mentioning the same slot.
+					fst_header: prev_header.clone(),
+					snd_header: header.clone(),
+				}));
+			} else {
+				//  We don't need to continue in case of duplicated header,
+				// since it's already saved and a possible equivocation
+				// would have been detected before.
+				return Ok(None)
+			}
+		}
+	}
+
+	let mut keys_to_delete = vec![];
+	let mut new_first_saved_slot = first_saved_slot;
+
+	if slot_now - first_saved_slot >= PRUNING_BOUND {
+		let prefix = SLOT_HEADER_MAP_KEY.to_vec();
+		new_first_saved_slot = slot_now.saturating_sub(MAX_SLOT_CAPACITY);
+
+		for s in first_saved_slot..new_first_saved_slot {
+			let mut p = prefix.clone();
+			s.using_encoded(|s| p.extend(s));
+			keys_to_delete.push(p);
+		}
+	}
+
+	headers_with_sig.push((header.clone(), signer.clone()));
+
+	backend.insert_aux(
+		&[
+			(&curr_slot_key[..], headers_with_sig.encode().as_slice()),
+			(&slot_header_start[..], new_first_saved_slot.encode().as_slice()),
+		],
+		&keys_to_delete.iter().map(|k| &k[..]).collect::<Vec<&[u8]>>()[..],
+	)?;
+
+	Ok(None)
+}
+
+#[cfg(test)]
+mod test {
+	use primitives::{sr25519, Pair};
+	use primitives::hash::H256;
+	use sr_primitives::testing::{Header as HeaderTest, Digest as DigestTest};
+	use test_client;
+
+	use super::{MAX_SLOT_CAPACITY, PRUNING_BOUND, check_equivocation};
+
+	fn create_header(number: u64) -> HeaderTest {
+		// so that different headers for the same number get different hashes
+		let parent_hash = H256::random();
+
+		let header = HeaderTest {
+			parent_hash,
+			number,
+			state_root: Default::default(),
+			extrinsics_root: Default::default(),
+			digest: DigestTest { logs: vec![], },
+		};
+
+		header
+	}
+
+	#[test]
+	fn check_equivocation_works() {
+		let client = test_client::new();
+		let (pair, _seed) = sr25519::Pair::generate();
+		let public = pair.public();
+
+		let header1 = create_header(1); // @ slot 2
+		let header2 = create_header(2); // @ slot 2
+		let header3 = create_header(2); // @ slot 4
+		let header4 = create_header(3); // @ slot MAX_SLOT_CAPACITY + 4
+		let header5 = create_header(4); // @ slot MAX_SLOT_CAPACITY + 4
+		let header6 = create_header(3); // @ slot 4
+
+		// It's ok to sign same headers.
+		assert!(
+			check_equivocation(
+				&client,
+				2,
+				2,
+				&header1,
+				&public,
+			).unwrap().is_none(),
+		);
+
+		assert!(
+			check_equivocation(
+				&client,
+				3,
+				2,
+				&header1,
+				&public,
+			).unwrap().is_none(),
+		);
+
+		// But not two different headers at the same slot.
+		assert!(
+			check_equivocation(
+				&client,
+				4,
+				2,
+				&header2,
+				&public,
+			).unwrap().is_some(),
+		);
+
+		// Different slot is ok.
+		assert!(
+			check_equivocation(
+				&client,
+				5,
+				4,
+				&header3,
+				&public,
+			).unwrap().is_none(),
+		);
+
+		// Here we trigger pruning and save header 4.
+		assert!(
+			check_equivocation(
+				&client,
+				PRUNING_BOUND + 2,
+				MAX_SLOT_CAPACITY + 4,
+				&header4,
+				&public,
+			).unwrap().is_none(),
+		);
+
+		// This fails because header 5 is an equivocation of header 4.
+		assert!(
+			check_equivocation(
+				&client,
+				PRUNING_BOUND + 3,
+				MAX_SLOT_CAPACITY + 4,
+				&header5,
+				&public,
+			).unwrap().is_some(),
+		);
+
+		// This is ok because we pruned the corresponding header. Shows that we are pruning.
+		assert!(
+			check_equivocation(
+				&client,
+				PRUNING_BOUND + 4,
+				4,
+				&header6,
+				&public,
+			).unwrap().is_none(),
+		);
+	}
+}
@@ -0,0 +1,430 @@
+// Copyright 2019 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Substrate is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Slots functionality for Substrate.
+//!
+//! Some consensus algorithms have a concept of *slots*, which are intervals in
+//! time during which certain events can and/or must occur.  This crate
+//! provides generic functionality for slots.
+
+#![deny(warnings)]
+#![forbid(unsafe_code, missing_docs)]
+
+mod slots;
+mod aux_schema;
+
+pub use slots::{SignedDuration, SlotInfo};
+use slots::Slots;
+pub use aux_schema::{check_equivocation, MAX_SLOT_CAPACITY, PRUNING_BOUND};
+
+use codec::{Decode, Encode};
+use consensus_common::{BlockImport, Proposer, SyncOracle, SelectChain};
+use futures::{prelude::*, future::{self, Either}};
+use futures_timer::Delay;
+use inherents::{InherentData, InherentDataProviders};
+use log::{debug, error, info, warn};
+use sr_primitives::generic::BlockId;
+use sr_primitives::traits::{ApiRef, Block as BlockT, Header, ProvideRuntimeApi};
+use std::{fmt::Debug, ops::Deref, pin::Pin, sync::Arc};
+use substrate_telemetry::{telemetry, CONSENSUS_DEBUG, CONSENSUS_WARN, CONSENSUS_INFO};
+use parking_lot::Mutex;
+use client_api;
+
+/// A worker that should be invoked at every new slot.
+pub trait SlotWorker<B: BlockT> {
+	/// The type of the future that will be returned when a new slot is
+	/// triggered.
+	type OnSlot: Future<Output = Result<(), consensus_common::Error>>;
+
+	/// Called when a new slot is triggered.
+	fn on_slot(&mut self, chain_head: B::Header, slot_info: SlotInfo) -> Self::OnSlot;
+}
+
+/// A skeleton implementation for `SlotWorker` which tries to claim a slot at
+/// its beginning and tries to produce a block if successfully claimed, timing
+/// out if block production takes too long.
+pub trait SimpleSlotWorker<B: BlockT> {
+	/// A handle to a `BlockImport`.
+	type BlockImport: BlockImport<B> + Send + 'static;
+
+	/// A handle to a `SyncOracle`.
+	type SyncOracle: SyncOracle;
+
+	/// The type of proposer to use to build blocks.
+	type Proposer: Proposer<B>;
+
+	/// Data associated with a slot claim.
+	type Claim: Send + 'static;
+
+	/// Epoch data necessary for authoring.
+	type EpochData;
+
+	/// The logging target to use when logging messages.
+	fn logging_target(&self) -> &'static str;
+
+	/// A handle to a `BlockImport`.
+	fn block_import(&self) -> Arc<Mutex<Self::BlockImport>>;
+
+	/// Returns the epoch data necessary for authoring. For time-dependent epochs,
+	/// use the provided slot number as a canonical source of time.
+	fn epoch_data(&self, header: &B::Header, slot_number: u64) -> Result<Self::EpochData, consensus_common::Error>;
+
+	/// Returns the number of authorities given the epoch data.
+	fn authorities_len(&self, epoch_data: &Self::EpochData) -> usize;
+
+	/// Tries to claim the given slot, returning an object with claim data if successful.
+	fn claim_slot(
+		&self,
+		header: &B::Header,
+		slot_number: u64,
+		epoch_data: &Self::EpochData,
+	) -> Option<Self::Claim>;
+
+	/// Return the pre digest data to include in a block authored with the given claim.
+	fn pre_digest_data(&self, slot_number: u64, claim: &Self::Claim) -> Vec<sr_primitives::DigestItem<B::Hash>>;
+
+	/// Returns a function which produces a `BlockImportParams`.
+	fn block_import_params(&self) -> Box<dyn Fn(
+		B::Header,
+		&B::Hash,
+		Vec<B::Extrinsic>,
+		Self::Claim,
+	) -> consensus_common::BlockImportParams<B> + Send>;
+
+	/// Whether to force authoring if offline.
+	fn force_authoring(&self) -> bool;
+
+	/// Returns a handle to a `SyncOracle`.
+	fn sync_oracle(&mut self) -> &mut Self::SyncOracle;
+
+	/// Returns a `Proposer` to author on top of the given block.
+	fn proposer(&mut self, block: &B::Header) -> Result<Self::Proposer, consensus_common::Error>;
+
+	/// Implements the `on_slot` functionality from `SlotWorker`.
+	fn on_slot(&mut self, chain_head: B::Header, slot_info: SlotInfo)
+		-> Pin<Box<dyn Future<Output = Result<(), consensus_common::Error>> + Send>> where
+		Self: Send + Sync,
+		<Self::Proposer as Proposer<B>>::Create: Unpin + Send + 'static,
+	{
+		let (timestamp, slot_number, slot_duration) =
+			(slot_info.timestamp, slot_info.number, slot_info.duration);
+
+		let epoch_data = match self.epoch_data(&chain_head, slot_number) {
+			Ok(epoch_data) => epoch_data,
+			Err(err) => {
+				warn!("Unable to fetch epoch data at block {:?}: {:?}", chain_head.hash(), err);
+
+				telemetry!(
+					CONSENSUS_WARN; "slots.unable_fetching_authorities";
+					"slot" => ?chain_head.hash(),
+					"err" => ?err,
+				);
+
+				return Box::pin(future::ready(Ok(())));
+			}
+		};
+
+		let authorities_len = self.authorities_len(&epoch_data);
+
+		if !self.force_authoring() && self.sync_oracle().is_offline() && authorities_len > 1 {
+			debug!(target: self.logging_target(), "Skipping proposal slot. Waiting for the network.");
+			telemetry!(
+				CONSENSUS_DEBUG;
+				"slots.skipping_proposal_slot";
+				"authorities_len" => authorities_len,
+			);
+
+			return Box::pin(future::ready(Ok(())));
+		}
+
+		let claim = match self.claim_slot(&chain_head, slot_number, &epoch_data) {
+			None => return Box::pin(future::ready(Ok(()))),
+			Some(claim) => claim,
+		};
+
+		debug!(
+			target: self.logging_target(), "Starting authorship at slot {}; timestamp = {}",
+			slot_number,
+			timestamp,
+		);
+
+		telemetry!(CONSENSUS_DEBUG; "slots.starting_authorship";
+			"slot_num" => slot_number,
+			"timestamp" => timestamp,
+		);
+
+		let mut proposer = match self.proposer(&chain_head) {
+			Ok(proposer) => proposer,
+			Err(err) => {
+				warn!("Unable to author block in slot {:?}: {:?}", slot_number, err);
+
+				telemetry!(CONSENSUS_WARN; "slots.unable_authoring_block";
+					"slot" => slot_number, "err" => ?err
+				);
+
+				return Box::pin(future::ready(Ok(())));
+			},
+		};
+
+		let remaining_duration = slot_info.remaining_duration();
+		let logs = self.pre_digest_data(slot_number, &claim);
+
+		// deadline our production to approx. the end of the slot
+		let proposal_work = futures::future::select(
+			proposer.propose(
+				slot_info.inherent_data,
+				sr_primitives::generic::Digest {
+					logs,
+				},
+				remaining_duration,
+			).map_err(|e| consensus_common::Error::ClientImport(format!("{:?}", e))),
+			Delay::new(remaining_duration)
+				.map_err(consensus_common::Error::FaultyTimer)
+		).map(|v| match v {
+			futures::future::Either::Left((b, _)) => b.map(|b| (b, claim)),
+			futures::future::Either::Right((Ok(_), _)) =>
+				Err(consensus_common::Error::ClientImport("Timeout in the Slots proposer".into())),
+			futures::future::Either::Right((Err(err), _)) => Err(err),
+		});
+
+		let block_import_params_maker = self.block_import_params();
+		let block_import = self.block_import();
+		let logging_target = self.logging_target();
+
+		Box::pin(proposal_work.map_ok(move |(block, claim)| {
+			// minor hack since we don't have access to the timestamp
+			// that is actually set by the proposer.
+			let slot_after_building = SignedDuration::default().slot_now(slot_duration);
+			if slot_after_building != slot_number {
+				info!("Discarding proposal for slot {}; block production took too long", slot_number);
+				// If the node was compiled with debug, tell the user to use release optimizations.
+				#[cfg(build_type="debug")]
+				info!("Recompile your node in `--release` mode to mitigate this problem.");
+				telemetry!(CONSENSUS_INFO; "slots.discarding_proposal_took_too_long";
+					"slot" => slot_number,
+				);
+
+				return;
+			}
+
+			let (header, body) = block.deconstruct();
+			let header_num = *header.number();
+			let header_hash = header.hash();
+			let parent_hash = *header.parent_hash();
+
+			let block_import_params = block_import_params_maker(
+				header,
+				&header_hash,
+				body,
+				claim,
+			);
+
+			info!("Pre-sealed block for proposal at {}. Hash now {:?}, previously {:?}.",
+					header_num,
+					block_import_params.post_header().hash(),
+					header_hash,
+			);
+
+			telemetry!(CONSENSUS_INFO; "slots.pre_sealed_block";
+				"header_num" => ?header_num,
+				"hash_now" => ?block_import_params.post_header().hash(),
+				"hash_previously" => ?header_hash,
+			);
+
+			if let Err(err) = block_import.lock().import_block(block_import_params, Default::default()) {
+				warn!(target: logging_target,
+					"Error with block built on {:?}: {:?}",
+					parent_hash,
+					err,
+				);
+
+				telemetry!(CONSENSUS_WARN; "slots.err_with_block_built_on";
+					"hash" => ?parent_hash, "err" => ?err,
+				);
+			}
+		}))
+	}
+}
+
+/// Slot compatible inherent data.
+pub trait SlotCompatible {
+	/// Extract timestamp and slot from inherent data.
+	fn extract_timestamp_and_slot(
+		&self,
+		inherent: &InherentData,
+	) -> Result<(u64, u64, std::time::Duration), consensus_common::Error>;
+
+	/// Get the difference between chain time and local time.  Defaults to
+	/// always returning zero.
+	fn time_offset() -> SignedDuration { Default::default() }
+}
+
+/// Start a new slot worker.
+///
+/// Every time a new slot is triggered, `worker.on_slot` is called and the future it returns is
+/// polled until completion, unless we are major syncing.
+pub fn start_slot_worker<B, C, W, T, SO, SC>(
+	slot_duration: SlotDuration<T>,
+	client: C,
+	mut worker: W,
+	mut sync_oracle: SO,
+	inherent_data_providers: InherentDataProviders,
+	timestamp_extractor: SC,
+) -> impl Future<Output = ()>
+where
+	B: BlockT,
+	C: SelectChain<B> + Clone,
+	W: SlotWorker<B>,
+	W::OnSlot: Unpin,
+	SO: SyncOracle + Send + Clone,
+	SC: SlotCompatible + Unpin,
+	T: SlotData + Clone,
+{
+	let SlotDuration(slot_duration) = slot_duration;
+
+	// rather than use a timer interval, we schedule our waits ourselves
+	Slots::<SC>::new(
+		slot_duration.slot_duration(),
+		inherent_data_providers,
+		timestamp_extractor,
+	).inspect_err(|e| debug!(target: "slots", "Faulty timer: {:?}", e))
+		.try_for_each(move |slot_info| {
+			// only propose when we are not syncing.
+			if sync_oracle.is_major_syncing() {
+				debug!(target: "slots", "Skipping proposal slot due to sync.");
+				return Either::Right(future::ready(Ok(())));
+			}
+
+			let slot_num = slot_info.number;
+			let chain_head = match client.best_chain() {
+				Ok(x) => x,
+				Err(e) => {
+					warn!(target: "slots", "Unable to author block in slot {}. \
+					no best block header: {:?}", slot_num, e);
+					return Either::Right(future::ready(Ok(())));
+				}
+			};
+
+			Either::Left(worker.on_slot(chain_head, slot_info).map_err(
+				|e| {
+					warn!(target: "slots", "Encountered consensus error: {:?}", e);
+				}).or_else(|_| future::ready(Ok(())))
+			)
+		}).then(|res| {
+			if let Err(err) = res {
+				warn!(target: "slots", "Slots stream terminated with an error: {:?}", err);
+			}
+			future::ready(())
+		})
+}
+
+/// A header which has been checked
+pub enum CheckedHeader<H, S> {
+	/// A header which has slot in the future. this is the full header (not stripped)
+	/// and the slot in which it should be processed.
+	Deferred(H, u64),
+	/// A header which is fully checked, including signature. This is the pre-header
+	/// accompanied by the seal components.
+	///
+	/// Includes the digest item that encoded the seal.
+	Checked(H, S),
+}
+
+/// A type from which a slot duration can be obtained.
+pub trait SlotData {
+	/// Gets the slot duration.
+	fn slot_duration(&self) -> u64;
+
+	/// The static slot key
+	const SLOT_KEY: &'static [u8];
+}
+
+impl SlotData for u64 {
+	fn slot_duration(&self) -> u64 {
+		*self
+	}
+
+	const SLOT_KEY: &'static [u8] = b"aura_slot_duration";
+}
+
+/// A slot duration. Create with `get_or_compute`.
+// The internal member should stay private here to maintain invariants of
+// `get_or_compute`.
+#[derive(Clone, Copy, Debug, Encode, Decode, Hash, PartialOrd, Ord, PartialEq, Eq)]
+pub struct SlotDuration<T>(T);
+
+impl<T> Deref for SlotDuration<T> {
+	type Target = T;
+	fn deref(&self) -> &T {
+		&self.0
+	}
+}
+
+impl<T: SlotData + Clone> SlotData for SlotDuration<T> {
+	/// Get the slot duration in milliseconds.
+	fn slot_duration(&self) -> u64
+		where T: SlotData,
+	{
+		self.0.slot_duration()
+	}
+
+	const SLOT_KEY: &'static [u8] = T::SLOT_KEY;
+}
+
+impl<T: Clone> SlotDuration<T> {
+	/// Either fetch the slot duration from disk or compute it from the
+	/// genesis state.
+	///
+	/// `slot_key` is marked as `'static`, as it should really be a
+	/// compile-time constant.
+	pub fn get_or_compute<B: BlockT, C, CB>(client: &C, cb: CB) -> client_api::error::Result<Self> where
+		C: client_api::backend::AuxStore,
+		C: ProvideRuntimeApi,
+		CB: FnOnce(ApiRef<C::Api>, &BlockId<B>) -> client_api::error::Result<T>,
+		T: SlotData + Encode + Decode + Debug,
+	{
+		match client.get_aux(T::SLOT_KEY)? {
+			Some(v) => <T as codec::Decode>::decode(&mut &v[..])
+				.map(SlotDuration)
+				.map_err(|_| {
+					client_api::error::Error::Backend({
+						error!(target: "slots", "slot duration kept in invalid format");
+						"slot duration kept in invalid format".to_string()
+					})
+				}),
+			None => {
+				use sr_primitives::traits::Zero;
+				let genesis_slot_duration =
+					cb(client.runtime_api(), &BlockId::number(Zero::zero()))?;
+
+				info!(
+					"Loaded block-time = {:?} milliseconds from genesis on first-launch",
+					genesis_slot_duration
+				);
+
+				genesis_slot_duration
+					.using_encoded(|s| client.insert_aux(&[(T::SLOT_KEY, &s[..])], &[]))?;
+
+				Ok(SlotDuration(genesis_slot_duration))
+			}
+		}
+	}
+
+	/// Returns slot data value.
+	pub fn get(&self) -> T {
+		self.0.clone()
+	}
+}
@@ -0,0 +1,176 @@
+// Copyright 2019 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Substrate is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Utility stream for yielding slots in a loop.
+//!
+//! This is used instead of `futures_timer::Interval` because it was unreliable.
+
+use super::SlotCompatible;
+use consensus_common::Error;
+use futures::{prelude::*, task::Context, task::Poll};
+use inherents::{InherentData, InherentDataProviders};
+
+use std::{pin::Pin, time::{Duration, Instant}};
+use futures_timer::Delay;
+
+/// Returns current duration since unix epoch.
+pub fn duration_now() -> Duration {
+	use std::time::SystemTime;
+	let now = SystemTime::now();
+	now.duration_since(SystemTime::UNIX_EPOCH).unwrap_or_else(|e| panic!(
+		"Current time {:?} is before unix epoch. Something is wrong: {:?}",
+		now,
+		e,
+	))
+}
+
+
+/// A `Duration` with a sign (before or after).  Immutable.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+pub struct SignedDuration {
+	offset: Duration,
+	is_positive: bool,
+}
+
+impl SignedDuration {
+	/// Construct a `SignedDuration`
+	pub fn new(offset: Duration, is_positive: bool) -> Self {
+		Self { offset, is_positive }
+	}
+
+	/// Get the slot for now.  Panics if `slot_duration` is 0.
+	pub fn slot_now(&self, slot_duration: u64) -> u64 {
+		(if self.is_positive {
+			duration_now() + self.offset
+		} else {
+			duration_now() - self.offset
+		}.as_millis() as u64) / slot_duration
+	}
+}
+
+/// Returns the duration until the next slot, based on current duration since
+pub fn time_until_next(now: Duration, slot_duration: u64) -> Duration {
+	let remaining_full_millis = slot_duration - (now.as_millis() as u64 % slot_duration) - 1;
+	Duration::from_millis(remaining_full_millis)
+}
+
+/// Information about a slot.
+pub struct SlotInfo {
+	/// The slot number.
+	pub number: u64,
+	/// Current timestamp.
+	pub timestamp: u64,
+	/// The instant at which the slot ends.
+	pub ends_at: Instant,
+	/// The inherent data.
+	pub inherent_data: InherentData,
+	/// Slot duration.
+	pub duration: u64,
+}
+
+impl SlotInfo {
+	/// Yields the remaining duration in the slot.
+	pub fn remaining_duration(&self) -> Duration {
+		let now = Instant::now();
+		if now < self.ends_at {
+			self.ends_at.duration_since(now)
+		} else {
+			Duration::from_millis(0)
+		}
+	}
+}
+
+/// A stream that returns every time there is a new slot.
+pub(crate) struct Slots<SC> {
+	last_slot: u64,
+	slot_duration: u64,
+	inner_delay: Option<Delay>,
+	inherent_data_providers: InherentDataProviders,
+	timestamp_extractor: SC,
+}
+
+impl<SC> Slots<SC> {
+	/// Create a new `Slots` stream.
+	pub fn new(
+		slot_duration: u64,
+		inherent_data_providers: InherentDataProviders,
+		timestamp_extractor: SC,
+	) -> Self {
+		Slots {
+			last_slot: 0,
+			slot_duration,
+			inner_delay: None,
+			inherent_data_providers,
+			timestamp_extractor,
+		}
+	}
+}
+
+impl<SC: SlotCompatible + Unpin> Stream for Slots<SC> {
+	type Item = Result<SlotInfo, Error>;
+
+	fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
+		loop {
+			let slot_duration = self.slot_duration;
+			self.inner_delay = match self.inner_delay.take() {
+				None => {
+					// schedule wait.
+					let wait_dur = time_until_next(duration_now(), slot_duration);
+					Some(Delay::new(wait_dur))
+				}
+				Some(d) => Some(d),
+			};
+
+			if let Some(ref mut inner_delay) = self.inner_delay {
+				match Future::poll(Pin::new(inner_delay), cx) {
+					Poll::Pending => return Poll::Pending,
+					Poll::Ready(Err(err)) => return Poll::Ready(Some(Err(Error::FaultyTimer(err)))),
+					Poll::Ready(Ok(())) => {}
+				}
+			}
+
+			// timeout has fired.
+
+			let inherent_data = match self.inherent_data_providers.create_inherent_data() {
+				Ok(id) => id,
+				Err(err) => return Poll::Ready(Some(Err(consensus_common::Error::InherentData(err)))),
+			};
+			let result = self.timestamp_extractor.extract_timestamp_and_slot(&inherent_data);
+			let (timestamp, slot_num, offset) = match result {
+				Ok(v) => v,
+				Err(err) => return Poll::Ready(Some(Err(err))),
+			};
+			// reschedule delay for next slot.
+			let ends_in = offset +
+				time_until_next(Duration::from_millis(timestamp), slot_duration);
+			let ends_at = Instant::now() + ends_in;
+			self.inner_delay = Some(Delay::new(ends_in));
+
+			// never yield the same slot twice.
+			if slot_num > self.last_slot {
+				self.last_slot = slot_num;
+
+				break Poll::Ready(Some(Ok(SlotInfo {
+					number: slot_num,
+					duration: self.slot_duration,
+					timestamp,
+					ends_at,
+					inherent_data,
+				})))
+			}
+		}
+	}
+}