Adds babe rpc support (#4729)

* babe_epochAuthorship
remove test-helpers from sp-keyring, bump spec_version, impl_version

* bump Cargo.lock

* add BabeRPC to node-rpc

* rename to BabeApi, remove err_derive

* pass &ServiceBuilder to with_rpc_extensions callback

* sc-consensus-babe-rpc

* Update client/consensus/babe/src/lib.rs

Co-Authored-By: Tomasz Drwięga <tomusdrw@users.noreply.github.com>

* Better docs, code style chanegs

Co-Authored-By: André Silva <andre.beat@gmail.com>

* new line at the end of Cargo.toml

Co-authored-by: Tomasz Drwięga <tomusdrw@users.noreply.github.com>
Co-authored-by: André Silva <andre.beat@gmail.com>

substrate/Cargo.lock

@@ -3501,7 +3501,14 @@ dependencies = [
  "pallet-contracts-rpc",
  "pallet-transaction-payment-rpc",
  "sc-client",
+ "sc-consensus-babe",
+ "sc-consensus-babe-rpc",
+ "sc-consensus-epochs",
+ "sc-keystore",
  "sp-api",
+ "sp-blockchain",
+ "sp-consensus",
+ "sp-consensus-babe",
  "sp-runtime",
  "sp-transaction-pool",
  "substrate-frame-rpc-system",
@@ -5840,6 +5847,7 @@ dependencies = [
  "sc-service",
  "sc-telemetry",
  "schnorrkel",
+ "serde",
  "sp-api",
  "sp-application-crypto",
  "sp-block-builder",
@@ -5858,6 +5866,31 @@ dependencies = [
  "tokio 0.1.22",
 ]
 
+[[package]]
+name = "sc-consensus-babe-rpc"
+version = "0.8.0"
+dependencies = [
+ "derive_more",
+ "futures 0.3.4",
+ "jsonrpc-core",
+ "jsonrpc-core-client",
+ "jsonrpc-derive",
+ "sc-consensus-babe",
+ "sc-consensus-epochs",
+ "sc-keystore",
+ "serde",
+ "sp-api",
+ "sp-application-crypto",
+ "sp-blockchain",
+ "sp-consensus",
+ "sp-consensus-babe",
+ "sp-core",
+ "sp-keyring",
+ "sp-runtime",
+ "substrate-test-runtime-client",
+ "tempfile",
+]
+
 [[package]]
 name = "sc-consensus-epochs"
 version = "0.8.0"

substrate/Cargo.toml

@@ -23,6 +23,7 @@ members = [
 	"client/cli",
 	"client/consensus/aura",
 	"client/consensus/babe",
+	"client/consensus/babe/rpc",
 	"client/consensus/manual-seal",
 	"client/consensus/pow",
 	"client/consensus/uncles",

substrate/bin/node/cli/src/service.rs

@@ -95,8 +95,21 @@ macro_rules! new_full_start {
 				import_setup = Some((block_import, grandpa_link, babe_link));
 				Ok(import_queue)
 			})?
-			.with_rpc_extensions(|client, pool, _backend, fetcher, _remote_blockchain| -> Result<RpcExtension, _> {
-				Ok(node_rpc::create(client, pool, node_rpc::LightDeps::none(fetcher)))
+			.with_rpc_extensions(|builder| -> Result<RpcExtension, _> {
+				let babe_link = import_setup.as_ref().map(|s| &s.2)
+					.expect("BabeLink is present for full services or set up failed; qed.");
+				let deps = node_rpc::FullDeps {
+					client: builder.client().clone(),
+					pool: builder.pool(),
+					select_chain: builder.select_chain().cloned()
+						.expect("SelectChain is present for full services or set up failed; qed."),
+					babe: node_rpc::BabeDeps {
+						keystore: builder.keystore(),
+						babe_config: sc_consensus_babe::BabeLink::config(babe_link).clone(),
+						shared_epoch_changes: sc_consensus_babe::BabeLink::epoch_changes(babe_link).clone()
+					}
+				};
+				Ok(node_rpc::create_full(deps))
 			})?;
 
 		(builder, import_setup, inherent_data_providers)
@@ -352,14 +365,21 @@ pub fn new_light(config: NodeConfiguration)
 		.with_finality_proof_provider(|client, backend|
 			Ok(Arc::new(GrandpaFinalityProofProvider::new(backend, client)) as _)
 		)?
-		.with_rpc_extensions(|client, pool, _backend, fetcher, remote_blockchain| -> Result<RpcExtension, _> {
-			let fetcher = fetcher
+		.with_rpc_extensions(|builder,| ->
+			Result<RpcExtension, _>
+		{
+			let fetcher = builder.fetcher()
 				.ok_or_else(|| "Trying to start node RPC without active fetcher")?;
-			let remote_blockchain = remote_blockchain
+			let remote_blockchain = builder.remote_backend()
 				.ok_or_else(|| "Trying to start node RPC without active remote blockchain")?;
 
-			let light_deps = node_rpc::LightDeps { remote_blockchain, fetcher };
-			Ok(node_rpc::create(client, pool, Some(light_deps)))
+			let light_deps = node_rpc::LightDeps {
+				remote_blockchain,
+				fetcher,
+				client: builder.client().clone(),
+				pool: builder.pool(),
+			};
+			Ok(node_rpc::create_light(light_deps))
 		})?
 		.build()?;
 

substrate/bin/node/rpc/Cargo.toml

@@ -12,7 +12,14 @@ node-primitives = { version = "2.0.0", path = "../primitives" }
 node-runtime = { version = "2.0.0", path = "../runtime" }
 sp-runtime = { version = "2.0.0", path = "../../../primitives/runtime" }
 sp-api = { version = "2.0.0", path = "../../../primitives/api" }
-pallet-contracts-rpc = { version = "0.8.0", path = "../../../frame/contracts/rpc/" }
+pallet-contracts-rpc = { version = "0.8", path = "../../../frame/contracts/rpc/" }
 pallet-transaction-payment-rpc = { version = "2.0.0", path = "../../../frame/transaction-payment/rpc/" }
 substrate-frame-rpc-system = { version = "2.0.0", path = "../../../utils/frame/rpc/system" }
 sp-transaction-pool = { version = "2.0.0", path = "../../../primitives/transaction-pool" }
+sc-consensus-babe = { version = "0.8", path = "../../../client/consensus/babe" }
+sc-consensus-babe-rpc = { version = "0.8", path = "../../../client/consensus/babe/rpc" }
+sp-consensus-babe = { version = "0.8", path = "../../../primitives/consensus/babe" }
+sc-keystore = { version = "2.0.0", path = "../../../client/keystore" }
+sc-consensus-epochs = { version = "0.8", path = "../../../client/consensus/epochs" }
+sp-consensus = { version = "0.8", path = "../../../primitives/consensus/common" }
+sp-blockchain = { version = "2.0.0", path = "../../../primitives/blockchain" }

substrate/bin/node/rpc/src/lib.rs

@@ -29,73 +29,130 @@
 
 #![warn(missing_docs)]
 
-use std::sync::Arc;
+use std::{sync::Arc, fmt};
 
 use node_primitives::{Block, BlockNumber, AccountId, Index, Balance};
 use node_runtime::UncheckedExtrinsic;
 use sp_api::ProvideRuntimeApi;
 use sp_transaction_pool::TransactionPool;
+use sp_blockchain::{Error as BlockChainError, HeaderMetadata, HeaderBackend};
+use sp_consensus::SelectChain;
+use sc_keystore::KeyStorePtr;
+use sp_consensus_babe::BabeApi;
+use sc_consensus_epochs::SharedEpochChanges;
+use sc_consensus_babe::{Config, Epoch};
+use sc_consensus_babe_rpc::BabeRPCHandler;
 
 /// Light client extra dependencies.
-pub struct LightDeps<F> {
+pub struct LightDeps<C, F, P> {
+	/// The client instance to use.
+	pub client: Arc<C>,
+	/// Transaction pool instance.
+	pub pool: Arc<P>,
 	/// Remote access to the blockchain (async).
 	pub remote_blockchain: Arc<dyn sc_client::light::blockchain::RemoteBlockchain<Block>>,
 	/// Fetcher instance.
 	pub fetcher: Arc<F>,
 }
 
-impl<F> LightDeps<F> {
-	/// Create empty `LightDeps` with given `F` type.
-	///
-	/// This is a convenience method to be used in the service builder,
-	/// to make sure the type of the `LightDeps<F>` is matching.
-	pub fn none(_: Option<Arc<F>>) -> Option<Self> {
-		None
-	}
+/// Extra dependencies for BABE.
+pub struct BabeDeps {
+	/// BABE protocol config.
+	pub babe_config: Config,
+	/// BABE pending epoch changes.
+	pub shared_epoch_changes: SharedEpochChanges<Block, Epoch>,
+	/// The keystore that manages the keys of the node.
+	pub keystore: KeyStorePtr,
 }
 
-/// Instantiate all RPC extensions.
-///
-/// If you provide `LightDeps`, the system is configured for light client.
-pub fn create<C, P, M, F>(
-	client: Arc<C>,
-	pool: Arc<P>,
-	light_deps: Option<LightDeps<F>>,
+/// Full client dependencies.
+pub struct FullDeps<C, P, SC> {
+	/// The client instance to use.
+	pub client: Arc<C>,
+	/// Transaction pool instance.
+	pub pool: Arc<P>,
+	/// The SelectChain Strategy
+	pub select_chain: SC,
+	/// BABE specific dependencies.
+	pub babe: BabeDeps,
+}
+
+/// Instantiate all Full RPC extensions.
+pub fn create_full<C, P, M, SC>(
+	deps: FullDeps<C, P, SC>,
 ) -> jsonrpc_core::IoHandler<M> where
 	C: ProvideRuntimeApi<Block>,
-	C: sc_client::blockchain::HeaderBackend<Block>,
+	C: HeaderBackend<Block> + HeaderMetadata<Block, Error=BlockChainError> + 'static,
 	C: Send + Sync + 'static,
 	C::Api: substrate_frame_rpc_system::AccountNonceApi<Block, AccountId, Index>,
 	C::Api: pallet_contracts_rpc::ContractsRuntimeApi<Block, AccountId, Balance, BlockNumber>,
 	C::Api: pallet_transaction_payment_rpc::TransactionPaymentRuntimeApi<Block, Balance, UncheckedExtrinsic>,
-	F: sc_client::light::fetcher::Fetcher<Block> + 'static,
+	C::Api: BabeApi<Block>,
+	<C::Api as sp_api::ApiErrorExt>::Error: fmt::Debug,
 	P: TransactionPool + 'static,
 	M: jsonrpc_core::Metadata + Default,
+	SC: SelectChain<Block> +'static,
 {
-	use substrate_frame_rpc_system::{FullSystem, LightSystem, SystemApi};
+	use substrate_frame_rpc_system::{FullSystem, SystemApi};
 	use pallet_contracts_rpc::{Contracts, ContractsApi};
 	use pallet_transaction_payment_rpc::{TransactionPayment, TransactionPaymentApi};
 
 	let mut io = jsonrpc_core::IoHandler::default();
+	let FullDeps {
+		client,
+		pool,
+		select_chain,
+		babe
+	} = deps;
+	let BabeDeps {
+		keystore,
+		babe_config,
+		shared_epoch_changes,
+	} = babe;
 
-	if let Some(LightDeps { remote_blockchain, fetcher }) = light_deps {
-		io.extend_with(
-			SystemApi::<AccountId, Index>::to_delegate(LightSystem::new(client, remote_blockchain, fetcher, pool))
-		);
-	} else {
-		io.extend_with(
-			SystemApi::to_delegate(FullSystem::new(client.clone(), pool))
-		);
+	io.extend_with(
+		SystemApi::to_delegate(FullSystem::new(client.clone(), pool))
+	);
+	// Making synchronous calls in light client freezes the browser currently,
+	// more context: https://github.com/paritytech/substrate/pull/3480
+	// These RPCs should use an asynchronous caller instead.
+	io.extend_with(
+		ContractsApi::to_delegate(Contracts::new(client.clone()))
+	);
+	io.extend_with(
+		TransactionPaymentApi::to_delegate(TransactionPayment::new(client.clone()))
+	);
+	io.extend_with(
+		sc_consensus_babe_rpc::BabeApi::to_delegate(
+			BabeRPCHandler::new(client, shared_epoch_changes, keystore, babe_config, select_chain)
+		)
+	);
+
+	io
+}
+
+/// Instantiate all Light RPC extensions.
+pub fn create_light<C, P, M, F>(
+	deps: LightDeps<C, F, P>,
+) -> jsonrpc_core::IoHandler<M> where
+	C: sc_client::blockchain::HeaderBackend<Block>,
+	C: Send + Sync + 'static,
+	F: sc_client::light::fetcher::Fetcher<Block> + 'static,
+	P: TransactionPool + 'static,
+	M: jsonrpc_core::Metadata + Default,
+{
+	use substrate_frame_rpc_system::{LightSystem, SystemApi};
+
+	let LightDeps {
+		client,
+		pool,
+		remote_blockchain,
+		fetcher
+	} = deps;
+	let mut io = jsonrpc_core::IoHandler::default();
+	io.extend_with(
+		SystemApi::<AccountId, Index>::to_delegate(LightSystem::new(client, remote_blockchain, fetcher, pool))
+	);
 
-		// Making synchronous calls in light client freezes the browser currently,
-		// more context: https://github.com/paritytech/substrate/pull/3480
-		// These RPCs should use an asynchronous caller instead.
-		io.extend_with(
-			ContractsApi::to_delegate(Contracts::new(client.clone()))
-		);
-		io.extend_with(
-			TransactionPaymentApi::to_delegate(TransactionPayment::new(client))
-		);
-	}
 	io
 }

substrate/bin/node/runtime/src/lib.rs

@@ -83,7 +83,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
 	// implementation changes and behavior does not, then leave spec_version as
 	// is and increment impl_version.
 	spec_version: 220,
-	impl_version: 0,
+	impl_version: 1,
 	apis: RUNTIME_API_VERSIONS,
 };
 
@@ -737,6 +737,10 @@ impl_runtime_apis! {
 				secondary_slots: true,
 			}
 		}
+
+		fn current_epoch_start() -> sp_consensus_babe::SlotNumber {
+			Babe::current_epoch_start()
+		}
 	}
 
 	impl sp_authority_discovery::AuthorityDiscoveryApi<Block> for Runtime {

substrate/client/consensus/babe/Cargo.toml

@@ -14,6 +14,7 @@ sp-application-crypto = { version = "2.0.0", path = "../../../primitives/applica
 num-bigint = "0.2.3"
 num-rational = "0.2.2"
 num-traits = "0.2.8"
+serde = { version = "1.0.104", features = ["derive"] }
 sp-version = { version = "2.0.0", path = "../../../primitives/version" }
 sp-io = { version = "2.0.0", path = "../../../primitives/io" }
 sp-inherents = { version = "2.0.0", path = "../../../primitives/inherents" }

substrate/client/consensus/babe/rpc/Cargo.toml

@@ -0,0 +1,30 @@
+[package]
+name = "sc-consensus-babe-rpc"
+version = "0.8.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+description = "RPC extensions for the BABE consensus algorithm"
+edition = "2018"
+license = "GPL-3.0"
+
+[dependencies]
+sc-consensus-babe = { version = "0.8.0", path = "../" }
+jsonrpc-core = "14.0.3"
+jsonrpc-core-client = "14.0.3"
+jsonrpc-derive = "14.0.3"
+sp-consensus-babe = { version = "0.8", path = "../../../../primitives/consensus/babe" }
+serde = { version = "1.0.104", features=["derive"] }
+sp-blockchain = { version = "2.0.0", path = "../../../../primitives/blockchain" }
+sp-runtime = { version = "2.0.0", path = "../../../../primitives/runtime" }
+sc-consensus-epochs = { version = "0.8", path = "../../epochs" }
+futures = "0.3.1"
+derive_more = "0.99.2"
+sp-api = { version = "2.0.0", path = "../../../../primitives/api" }
+sp-consensus = { version = "0.8", path = "../../../../primitives/consensus/common" }
+sp-core = { version = "2.0.0", path = "../../../../primitives/core" }
+sc-keystore = { version = "2.0.0", path = "../../../keystore" }
+
+[dev-dependencies]
+substrate-test-runtime-client = { version = "2.0.0", path = "../../../../test-utils/runtime/client" }
+sp-application-crypto = { version = "2.0.0", path = "../../../../primitives/application-crypto" }
+sp-keyring = { version = "2.0.0", path = "../../../../primitives/keyring" }
+tempfile = "3.1.0"

substrate/client/consensus/babe/rpc/src/lib.rs

@@ -0,0 +1,248 @@
+// Copyright 2020 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/>.
+
+//! RPC api for babe.
+
+use sc_consensus_babe::{Epoch, authorship, Config};
+use futures::{FutureExt as _, TryFutureExt as _};
+use jsonrpc_core::{
+	Error as RpcError,
+	futures::future as rpc_future,
+};
+use jsonrpc_derive::rpc;
+use sc_consensus_epochs::{descendent_query, Epoch as EpochT, SharedEpochChanges};
+use sp_consensus_babe::{
+	AuthorityId,
+	BabeApi as BabeRuntimeApi,
+	digests::PreDigest,
+};
+use serde::{Deserialize, Serialize};
+use sc_keystore::KeyStorePtr;
+use sp_api::{ProvideRuntimeApi, BlockId};
+use sp_core::crypto::Pair;
+use sp_runtime::traits::{Block as BlockT, Header as _};
+use sp_consensus::{SelectChain, Error as ConsensusError};
+use sp_blockchain::{HeaderBackend, HeaderMetadata, Error as BlockChainError};
+use std::{collections::HashMap, fmt, sync::Arc};
+
+type FutureResult<T> = Box<dyn rpc_future::Future<Item = T, Error = RpcError> + Send>;
+
+/// Provides rpc methods for interacting with Babe.
+#[rpc]
+pub trait BabeApi {
+	/// Returns data about which slots (primary or secondary) can be claimed in the current epoch
+	/// with the keys in the keystore.
+	#[rpc(name = "babe_epochAuthorship")]
+	fn epoch_authorship(&self) -> FutureResult<HashMap<AuthorityId, EpochAuthorship>>;
+}
+
+/// Implements the BabeRPC trait for interacting with Babe.
+///
+/// Uses a background thread to calculate epoch_authorship data.
+pub struct BabeRPCHandler<B: BlockT, C, SC> {
+	/// shared reference to the client.
+	client: Arc<C>,
+	/// shared reference to EpochChanges
+	shared_epoch_changes: SharedEpochChanges<B, Epoch>,
+	/// shared reference to the Keystore
+	keystore: KeyStorePtr,
+	/// config (actually holds the slot duration)
+	babe_config: Config,
+	/// The SelectChain strategy
+	select_chain: SC,
+}
+
+impl<B: BlockT, C, SC> BabeRPCHandler<B, C, SC> {
+	/// Creates a new instance of the BabeRpc handler.
+	pub fn new(
+		client: Arc<C>,
+		shared_epoch_changes: SharedEpochChanges<B, Epoch>,
+		keystore: KeyStorePtr,
+		babe_config: Config,
+		select_chain: SC,
+	) -> Self {
+
+		Self {
+			client,
+			shared_epoch_changes,
+			keystore,
+			babe_config,
+			select_chain,
+		}
+	}
+}
+
+impl<B, C, SC> BabeApi for BabeRPCHandler<B, C, SC>
+	where
+		B: BlockT,
+		C: ProvideRuntimeApi<B> + HeaderBackend<B> + HeaderMetadata<B, Error=BlockChainError> + 'static,
+		C::Api: BabeRuntimeApi<B>,
+		<C::Api as sp_api::ApiErrorExt>::Error: fmt::Debug,
+		SC: SelectChain<B> + Clone + 'static,
+{
+	fn epoch_authorship(&self) -> FutureResult<HashMap<AuthorityId, EpochAuthorship>> {
+		let (
+			babe_config,
+			keystore,
+			shared_epoch,
+			client,
+			select_chain,
+		) = (
+			self.babe_config.clone(),
+			self.keystore.clone(),
+			self.shared_epoch_changes.clone(),
+			self.client.clone(),
+			self.select_chain.clone(),
+		);
+		let future = async move {
+			let header = select_chain.best_chain().map_err(Error::Consensus)?;
+			let epoch_start = client.runtime_api()
+				.current_epoch_start(&BlockId::Hash(header.hash()))
+				.map_err(|err| {
+					Error::StringError(format!("{:?}", err))
+				})?;
+			let epoch = epoch_data(&shared_epoch, &client, &babe_config, epoch_start, &select_chain)?;
+			let (epoch_start, epoch_end) = (epoch.start_slot(), epoch.end_slot());
+
+			let mut claims: HashMap<AuthorityId, EpochAuthorship> = HashMap::new();
+
+			for slot_number in epoch_start..epoch_end {
+				let epoch = epoch_data(&shared_epoch, &client, &babe_config, slot_number, &select_chain)?;
+				if let Some((claim, key)) = authorship::claim_slot(slot_number, &epoch, &babe_config, &keystore) {
+					match claim {
+						PreDigest::Primary { .. } => {
+							claims.entry(key.public()).or_default().primary.push(slot_number);
+						}
+						PreDigest::Secondary { .. } => {
+							claims.entry(key.public()).or_default().secondary.push(slot_number);
+						}
+					};
+				}
+			}
+
+			Ok(claims)
+		}.boxed();
+
+		Box::new(future.compat())
+	}
+}
+
+/// Holds information about the `slot_number`'s that can be claimed by a given key.
+#[derive(Default, Debug, Deserialize, Serialize)]
+pub struct EpochAuthorship {
+	/// the array of primary slots that can be claimed
+	primary: Vec<u64>,
+	/// the array of secondary slots that can be claimed
+	secondary: Vec<u64>,
+}
+
+/// Errors encountered by the RPC
+#[derive(Debug, derive_more::Display, derive_more::From)]
+pub enum Error {
+	/// Consensus error
+	Consensus(ConsensusError),
+	/// Errors that can be formatted as a String
+	StringError(String)
+}
+
+impl From<Error> for jsonrpc_core::Error {
+	fn from(error: Error) -> Self {
+		jsonrpc_core::Error {
+			message: format!("{}", error).into(),
+			code: jsonrpc_core::ErrorCode::ServerError(1234),
+			data: None,
+		}
+	}
+}
+
+/// fetches the epoch data for a given slot_number.
+fn epoch_data<B, C, SC>(
+	epoch_changes: &SharedEpochChanges<B, Epoch>,
+	client: &Arc<C>,
+	babe_config: &Config,
+	slot_number: u64,
+	select_chain: &SC,
+) -> Result<Epoch, Error>
+	where
+		B: BlockT,
+		C: HeaderBackend<B> + HeaderMetadata<B, Error=BlockChainError> + 'static,
+		SC: SelectChain<B>,
+{
+	let parent = select_chain.best_chain()?;
+	epoch_changes.lock().epoch_for_child_of(
+		descendent_query(&**client),
+		&parent.hash(),
+		parent.number().clone(),
+		slot_number,
+		|slot| babe_config.genesis_epoch(slot),
+	)
+		.map_err(|e| Error::Consensus(ConsensusError::ChainLookup(format!("{:?}", e))))?
+		.map(|e| e.into_inner())
+		.ok_or(Error::Consensus(ConsensusError::InvalidAuthoritiesSet))
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use substrate_test_runtime_client::{
+		DefaultTestClientBuilderExt,
+		TestClientBuilderExt,
+		TestClientBuilder,
+	};
+	use sp_application_crypto::AppPair;
+	use sp_keyring::Ed25519Keyring;
+	use sc_keystore::Store;
+
+	use std::sync::Arc;
+	use sc_consensus_babe::{Config, block_import, AuthorityPair};
+	use jsonrpc_core::IoHandler;
+
+	/// creates keystore backed by a temp file
+	fn create_temp_keystore<P: AppPair>(authority: Ed25519Keyring) -> (KeyStorePtr, tempfile::TempDir) {
+		let keystore_path = tempfile::tempdir().expect("Creates keystore path");
+		let keystore = Store::open(keystore_path.path(), None).expect("Creates keystore");
+		keystore.write().insert_ephemeral_from_seed::<P>(&authority.to_seed())
+			.expect("Creates authority key");
+
+		(keystore, keystore_path)
+	}
+
+	#[test]
+	fn rpc() {
+		let builder = TestClientBuilder::new();
+		let (client, longest_chain) = builder.build_with_longest_chain();
+		let client = Arc::new(client);
+		let config = Config::get_or_compute(&*client).expect("config available");
+		let (_, link) = block_import(
+			config.clone(),
+			client.clone(),
+			client.clone(),
+			client.clone(),
+		).expect("can initialize block-import");
+
+		let epoch_changes = link.epoch_changes().clone();
+		let select_chain = longest_chain;
+		let keystore = create_temp_keystore::<AuthorityPair>(Ed25519Keyring::Alice).0;
+		let handler = BabeRPCHandler::new(client.clone(), epoch_changes, keystore, config, select_chain);
+		let mut io = IoHandler::new();
+
+		io.extend_with(BabeApi::to_delegate(handler));
+		let request = r#"{"jsonrpc":"2.0","method":"babe_epochAuthorship","params": [],"id":1}"#;
+		let response = r#"{"jsonrpc":"2.0","result":{"5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY":{"primary":[0],"secondary":[1,2,4]}},"id":1}"#;
+
+		assert_eq!(Some(response.into()), io.handle_request_sync(request));
+	}
+}

substrate/client/consensus/babe/src/authorship.rs

@@ -144,7 +144,7 @@ fn claim_secondary_slot(
 /// a primary VRF based slot. If we are not able to claim it, then if we have
 /// secondary slots enabled for the given epoch, we will fallback to trying to
 /// claim a secondary slot.
-pub(super) fn claim_slot(
+pub fn claim_slot(
 	slot_number: SlotNumber,
 	epoch: &Epoch,
 	config: &BabeConfiguration,

substrate/client/consensus/babe/src/lib.rs

@@ -119,7 +119,7 @@ use sp_api::ApiExt;
 
 mod aux_schema;
 mod verification;
-mod authorship;
+pub mod authorship;
 #[cfg(test)]
 mod tests;
 

substrate/client/keystore/src/lib.rs

@@ -19,13 +19,10 @@
 #![warn(missing_docs)]
 
 use std::{collections::HashMap, path::PathBuf, fs::{self, File}, io::{self, Write}, sync::Arc};
-
 use sp_core::{
 	crypto::{KeyTypeId, Pair as PairT, Public, IsWrappedBy, Protected}, traits::BareCryptoStore,
 };
-
 use sp_application_crypto::{AppKey, AppPublic, AppPair, ed25519, sr25519};
-
 use parking_lot::RwLock;
 
 /// Keystore pointer

substrate/client/service/src/builder.rs

@@ -379,6 +379,30 @@ impl<TBl, TRtApi, TGen, TCSExt, TCl, TFchr, TSc, TImpQu, TFprb, TFpp, TNetP, TEx
 		self.select_chain.as_ref()
 	}
 
+	/// Returns a reference to the keystore
+	pub fn keystore(&self) -> Arc<RwLock<Keystore>> {
+		self.keystore.clone()
+	}
+
+	/// Returns a reference to the transaction pool stored in this builder
+	pub fn pool(&self) -> Arc<TExPool> {
+		self.transaction_pool.clone()
+	}
+
+	/// Returns a reference to the fetcher, only available if builder
+	/// was created with `new_light`.
+	pub fn fetcher(&self) -> Option<TFchr>
+		where TFchr: Clone
+	{
+		self.fetcher.clone()
+	}
+
+	/// Returns a reference to the remote_backend, only available if builder
+	/// was created with `new_light`.
+	pub fn remote_backend(&self) -> Option<Arc<dyn RemoteBlockchain<TBl>>> {
+		self.remote_backend.clone()
+	}
+
 	/// Defines which head-of-chain strategy to use.
 	pub fn with_opt_select_chain<USc>(
 		self,
@@ -647,23 +671,11 @@ impl<TBl, TRtApi, TGen, TCSExt, TCl, TFchr, TSc, TImpQu, TFprb, TFpp, TNetP, TEx
 	/// Defines the RPC extensions to use.
 	pub fn with_rpc_extensions<URpc>(
 		self,
-		rpc_ext_builder: impl FnOnce(
-			Arc<TCl>,
-			Arc<TExPool>,
-			Arc<Backend>,
-			Option<TFchr>,
-			Option<Arc<dyn RemoteBlockchain<TBl>>>,
-		) -> Result<URpc, Error>,
+		rpc_ext_builder: impl FnOnce(&Self) -> Result<URpc, Error>,
 	) -> Result<ServiceBuilder<TBl, TRtApi, TGen, TCSExt, TCl, TFchr, TSc, TImpQu, TFprb, TFpp,
 		TNetP, TExPool, URpc, Backend>, Error>
 	where TSc: Clone, TFchr: Clone {
-		let rpc_extensions = rpc_ext_builder(
-			self.client.clone(),
-			self.transaction_pool.clone(),
-			self.backend.clone(),
-			self.fetcher.clone(),
-			self.remote_backend.clone(),
-		)?;
+		let rpc_extensions = rpc_ext_builder(&self)?;
 
 		Ok(ServiceBuilder {
 			config: self.config,

substrate/frame/babe/src/lib.rs

@@ -365,7 +365,7 @@ impl<T: Trait> Module<T> {
 	// finds the start slot of the current epoch. only guaranteed to
 	// give correct results after `do_initialize` of the first block
 	// in the chain (as its result is based off of `GenesisSlot`).
-	fn current_epoch_start() -> SlotNumber {
+	pub fn current_epoch_start() -> SlotNumber {
 		(EpochIndex::get() * T::EpochDuration::get()) + GenesisSlot::get()
 	}
 

substrate/primitives/consensus/babe/src/lib.rs

@@ -139,5 +139,8 @@ sp_api::decl_runtime_apis! {
 		///
 		/// Dynamic configuration may be supported in the future.
 		fn configuration() -> BabeConfiguration;
+
+		/// Returns the slot number that started the current epoch.
+		fn current_epoch_start() -> SlotNumber;
 	}
 }

substrate/test-utils/runtime/src/lib.rs

@@ -52,7 +52,7 @@ use cfg_if::cfg_if;
 use sp_core::storage::ChildType;
 
 // Ensure Babe and Aura use the same crypto to simplify things a bit.
-pub use sp_consensus_babe::AuthorityId;
+pub use sp_consensus_babe::{AuthorityId, SlotNumber};
 pub type AuraId = sp_consensus_aura::sr25519::AuthorityId;
 
 // Include the WASM binary
@@ -606,6 +606,10 @@ cfg_if! {
 						secondary_slots: true,
 					}
 				}
+
+				fn current_epoch_start() -> SlotNumber {
+					<pallet_babe::Module<Runtime>>::current_epoch_start()
+				}
 			}
 
 			impl sp_offchain::OffchainWorkerApi<Block> for Runtime {
@@ -793,6 +797,10 @@ cfg_if! {
 						secondary_slots: true,
 					}
 				}
+
+				fn current_epoch_start() -> SlotNumber {
+					<pallet_babe::Module<Runtime>>::current_epoch_start()
+				}
 			}
 
 			impl sp_offchain::OffchainWorkerApi<Block> for Runtime {