Allow BabeConsensusDataProvider fork existing chain (#7078)

* parent affbc38afd
author Seun Lanlege <seunlanlege@gmail.com> 1599568164 +0100
committer Seun Lanlege <seunlanlege@gmail.com> 1604321289 +0100
gpgsig -----BEGIN PGP SIGNATURE-----

 iQGzBAABCgAdFiEECvQ02MnjnssnSbjr3HzzEhjN254FAl+gAAkACgkQ3HzzEhjN
 254soAv+KO5JA0HXSe0R0XS5TnwA3IxYsW+UvdF5dXFeC3jFdGTMvor818uoBePD
 dxzYEsUK6gjsNcM9+hpFhoy5JnUrUPInd2BZ7pmZiDuXmYJrHi0s7K5qL0EYDoe0
 m1egPNNyRR125ozJ24M+09c3OQsi3bvTx1TJaV9Aov8hK4So8UmlJTHWpkLw97ku
 HuTre2IPSFbV4GwJE40V+KNuDVHxaKL7zrInYScqbr6/hOTqBCvFn4ib3CjpF5HG
 zDAA5S2PrcbL9NQOothVcVB/TZr3IkhglCFqEjVyCX80IL0JkNZkw8jAh0B8uqXx
 Ug/c1/Mssa8F1jLZMmW45Cway60txqVbcWntPJAymGJbrRErOO/++oUrV0u1C65u
 LW7gXAaIJWQTX9KnX0SEyejNod7ubZktBz7n5WfkJAPIzdw5wtJalhLa673YTgQ9
 zyTPKiWjJj2myCq1AYrJvlK8hSsIBqbBFcUf1zX4SzZWKS+5mtp51o4gfVzcCRPd
 z/6/iPbB
 =g5tx
 -----END PGP SIGNATURE-----

BabeConsensusDataProvider works with existing chains

Co-authored-by: Bastian Köcher <bkchr@users.noreply.github.com>

Co-authored-by: Bastian Köcher <bkchr@users.noreply.github.com>

substrate/client/api/src/execution_extensions.rs

@@ -136,31 +136,9 @@ impl<Block: traits::Block> ExecutionExtensions<Block> {
 		*self.transaction_pool.write() = Some(Arc::downgrade(&pool) as _);
 	}
 
-	/// Create `ExecutionManager` and `Extensions` for given offchain call.
-	///
 	/// Based on the execution context and capabilities it produces
-	/// the right manager and extensions object to support desired set of APIs.
-	pub fn manager_and_extensions<E: std::fmt::Debug, R: codec::Codec>(
-		&self,
-		at: &BlockId<Block>,
-		context: ExecutionContext,
-	) -> (
-		ExecutionManager<DefaultHandler<R, E>>,
-		Extensions,
-	) {
-		let manager = match context {
-			ExecutionContext::BlockConstruction =>
-				self.strategies.block_construction.get_manager(),
-			ExecutionContext::Syncing =>
-				self.strategies.syncing.get_manager(),
-			ExecutionContext::Importing =>
-				self.strategies.importing.get_manager(),
-			ExecutionContext::OffchainCall(Some((_, capabilities))) if capabilities.has_all() =>
-				self.strategies.offchain_worker.get_manager(),
-			ExecutionContext::OffchainCall(_) =>
-				self.strategies.other.get_manager(),
-		};
-
+	/// the extensions object to support desired set of APIs.
+	pub fn extensions(&self, at: &BlockId<Block>, context: ExecutionContext) -> Extensions {
 		let capabilities = context.capabilities();
 
 		let mut extensions = self.extensions_factory.read().extensions_for(capabilities);
@@ -190,7 +168,35 @@ impl<Block: traits::Block> ExecutionExtensions<Block> {
 			);
 		}
 
-		(manager, extensions)
+		extensions
+	}
+
+	/// Create `ExecutionManager` and `Extensions` for given offchain call.
+	///
+	/// Based on the execution context and capabilities it produces
+	/// the right manager and extensions object to support desired set of APIs.
+	pub fn manager_and_extensions<E: std::fmt::Debug, R: codec::Codec>(
+		&self,
+		at: &BlockId<Block>,
+		context: ExecutionContext,
+	) -> (
+		ExecutionManager<DefaultHandler<R, E>>,
+		Extensions,
+	) {
+		let manager = match context {
+			ExecutionContext::BlockConstruction =>
+				self.strategies.block_construction.get_manager(),
+			ExecutionContext::Syncing =>
+				self.strategies.syncing.get_manager(),
+			ExecutionContext::Importing =>
+				self.strategies.importing.get_manager(),
+			ExecutionContext::OffchainCall(Some((_, capabilities))) if capabilities.has_all() =>
+				self.strategies.offchain_worker.get_manager(),
+			ExecutionContext::OffchainCall(_) =>
+				self.strategies.other.get_manager(),
+		};
+
+		(manager, self.extensions(at, context))
 	}
 }
 

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

@@ -15,9 +15,9 @@ targets = ["x86_64-unknown-linux-gnu"]
 [dependencies]
 sc-consensus-babe = { version = "0.8.0", path = "../" }
 sc-rpc-api = { version = "0.8.0", path = "../../../rpc-api" }
-jsonrpc-core = "15.0.0"
-jsonrpc-core-client = "15.0.0"
-jsonrpc-derive = "15.0.0"
+jsonrpc-core = "15.1.0"
+jsonrpc-core-client = "15.1.0"
+jsonrpc-derive = "15.1.0"
 sp-consensus-babe = { version = "0.8.0", path = "../../../../primitives/consensus/babe" }
 serde = { version = "1.0.104", features=["derive"] }
 sp-blockchain = { version = "2.0.0", path = "../../../../primitives/blockchain" }

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

@@ -199,58 +199,86 @@ impl Epoch {
 	}
 }
 
+/// Errors encountered by the babe authorship task.
 #[derive(derive_more::Display, Debug)]
-enum Error<B: BlockT> {
+pub enum Error<B: BlockT> {
+	/// Multiple BABE pre-runtime digests
 	#[display(fmt = "Multiple BABE pre-runtime digests, rejecting!")]
 	MultiplePreRuntimeDigests,
+	/// No BABE pre-runtime digest found
 	#[display(fmt = "No BABE pre-runtime digest found")]
 	NoPreRuntimeDigest,
+	/// Multiple BABE epoch change digests
 	#[display(fmt = "Multiple BABE epoch change digests, rejecting!")]
 	MultipleEpochChangeDigests,
+	/// Multiple BABE config change digests
 	#[display(fmt = "Multiple BABE config change digests, rejecting!")]
 	MultipleConfigChangeDigests,
+	/// Could not extract timestamp and slot
 	#[display(fmt = "Could not extract timestamp and slot: {:?}", _0)]
 	Extraction(sp_consensus::Error),
+	/// Could not fetch epoch
 	#[display(fmt = "Could not fetch epoch at {:?}", _0)]
 	FetchEpoch(B::Hash),
+	/// Header rejected: too far in the future
 	#[display(fmt = "Header {:?} rejected: too far in the future", _0)]
 	TooFarInFuture(B::Hash),
+	/// Parent unavailable. Cannot import
 	#[display(fmt = "Parent ({}) of {} unavailable. Cannot import", _0, _1)]
 	ParentUnavailable(B::Hash, B::Hash),
+	/// Slot number must increase
 	#[display(fmt = "Slot number must increase: parent slot: {}, this slot: {}", _0, _1)]
 	SlotNumberMustIncrease(u64, u64),
+	/// Header has a bad seal
 	#[display(fmt = "Header {:?} has a bad seal", _0)]
 	HeaderBadSeal(B::Hash),
+	/// Header is unsealed
 	#[display(fmt = "Header {:?} is unsealed", _0)]
 	HeaderUnsealed(B::Hash),
+	/// Slot author not found
 	#[display(fmt = "Slot author not found")]
 	SlotAuthorNotFound,
+	/// Secondary slot assignments are disabled for the current epoch.
 	#[display(fmt = "Secondary slot assignments are disabled for the current epoch.")]
 	SecondarySlotAssignmentsDisabled,
+	/// Bad signature
 	#[display(fmt = "Bad signature on {:?}", _0)]
 	BadSignature(B::Hash),
+	/// Invalid author: Expected secondary author
 	#[display(fmt = "Invalid author: Expected secondary author: {:?}, got: {:?}.", _0, _1)]
 	InvalidAuthor(AuthorityId, AuthorityId),
+	/// No secondary author expected.
 	#[display(fmt = "No secondary author expected.")]
 	NoSecondaryAuthorExpected,
+	/// VRF verification of block by author failed
 	#[display(fmt = "VRF verification of block by author {:?} failed: threshold {} exceeded", _0, _1)]
 	VRFVerificationOfBlockFailed(AuthorityId, u128),
+	/// VRF verification failed
 	#[display(fmt = "VRF verification failed: {:?}", _0)]
 	VRFVerificationFailed(SignatureError),
+	/// Could not fetch parent header
 	#[display(fmt = "Could not fetch parent header: {:?}", _0)]
 	FetchParentHeader(sp_blockchain::Error),
+	/// Expected epoch change to happen.
 	#[display(fmt = "Expected epoch change to happen at {:?}, s{}", _0, _1)]
 	ExpectedEpochChange(B::Hash, u64),
+	/// Unexpected config change.
 	#[display(fmt = "Unexpected config change")]
 	UnexpectedConfigChange,
+	/// Unexpected epoch change
 	#[display(fmt = "Unexpected epoch change")]
 	UnexpectedEpochChange,
+	/// Parent block has no associated weight
 	#[display(fmt = "Parent block of {} has no associated weight", _0)]
 	ParentBlockNoAssociatedWeight(B::Hash),
 	#[display(fmt = "Checking inherents failed: {}", _0)]
+	/// Check Inherents error
 	CheckInherents(String),
+	/// Client error
 	Client(sp_blockchain::Error),
+	/// Runtime error
 	Runtime(sp_inherents::Error),
+	/// Fork tree error
 	ForkTree(Box<fork_tree::Error<sp_blockchain::Error>>),
 }
 
@@ -669,7 +697,7 @@ impl<B, C, E, I, Error, SO> sc_consensus_slots::SimpleSlotWorker<B> for BabeSlot
 
 /// Extract the BABE pre digest from the given header. Pre-runtime digests are
 /// mandatory, the function will return `Err` if none is found.
-fn find_pre_digest<B: BlockT>(header: &B::Header) -> Result<PreDigest, Error<B>>
+pub fn find_pre_digest<B: BlockT>(header: &B::Header) -> Result<PreDigest, Error<B>>
 {
 	// genesis block doesn't contain a pre digest so let's generate a
 	// dummy one to not break any invariants in the rest of the code

substrate/client/consensus/manual-seal/Cargo.toml

@@ -15,11 +15,12 @@ targets = ["x86_64-unknown-linux-gnu"]
 [dependencies]
 derive_more = "0.99.2"
 futures = "0.3.4"
-jsonrpc-core = "15.0.0"
-jsonrpc-core-client = "15.0.0"
-jsonrpc-derive = "15.0.0"
+jsonrpc-core = "15.1.0"
+jsonrpc-core-client = "15.1.0"
+jsonrpc-derive = "15.1.0"
 log = "0.4.8"
 parking_lot = "0.10.0"
+codec = { package = "parity-scale-codec", version = "1.3.1" }
 serde = { version = "1.0", features=["derive"] }
 assert_matches = "1.3.0"
 
@@ -35,6 +36,7 @@ sp-inherents = { path = "../../../primitives/inherents", version = "2.0.0" }
 sp-runtime = {  path = "../../../primitives/runtime", version = "2.0.0" }
 sp-core = {  path = "../../../primitives/core", version = "2.0.0" }
 sp-keystore = {  path = "../../../primitives/keystore", version = "0.8.0" }
+sp-keyring = {  path = "../../../primitives/keyring", version = "2.0.0" }
 sp-api = {  path = "../../../primitives/api", version = "2.0.0" }
 sp-transaction-pool = { path = "../../../primitives/transaction-pool", version = "2.0.0" }
 sp-timestamp = { path = "../../../primitives/timestamp", version = "2.0.0" }

substrate/client/consensus/manual-seal/src/consensus/babe.rs

@@ -20,7 +20,7 @@
 
 use super::ConsensusDataProvider;
 use crate::Error;
-
+use codec::Encode;
 use std::{
 	any::Any,
 	borrow::Cow,
@@ -30,21 +30,24 @@ use std::{
 use sc_client_api::AuxStore;
 use sc_consensus_babe::{
 	Config, Epoch, authorship, CompatibleDigestItem, BabeIntermediate,
-	register_babe_inherent_data_provider, INTERMEDIATE_KEY,
+	register_babe_inherent_data_provider, INTERMEDIATE_KEY, find_pre_digest,
 };
-use sc_consensus_epochs::{SharedEpochChanges, descendent_query};
+use sc_consensus_epochs::{SharedEpochChanges, descendent_query, ViableEpochDescriptor, EpochHeader};
+use sp_keystore::SyncCryptoStorePtr;
 
 use sp_api::{ProvideRuntimeApi, TransactionFor};
 use sp_blockchain::{HeaderBackend, HeaderMetadata};
 use sp_consensus::BlockImportParams;
-use sp_consensus_babe::{BabeApi, inherents::BabeInherentData};
-use sp_keystore::SyncCryptoStorePtr;
+use sp_consensus_babe::{
+	BabeApi, inherents::BabeInherentData, ConsensusLog, BABE_ENGINE_ID, AuthorityId,
+	digests::{PreDigest, SecondaryPlainPreDigest, NextEpochDescriptor}, BabeAuthorityWeight,
+};
 use sp_inherents::{InherentDataProviders, InherentData, ProvideInherentData, InherentIdentifier};
 use sp_runtime::{
-	traits::{DigestItemFor, DigestFor, Block as BlockT, Header as _},
-	generic::Digest,
+	traits::{DigestItemFor, DigestFor, Block as BlockT, Zero, Header},
+	generic::{Digest, BlockId},
 };
-use sp_timestamp::{InherentType, InherentError, INHERENT_IDENTIFIER};
+use sp_timestamp::{InherentType, InherentError, INHERENT_IDENTIFIER, TimestampInherentData};
 
 /// Provides BABE-compatible predigests and BlockImportParams.
 /// Intended for use with BABE runtimes.
@@ -60,12 +63,15 @@ pub struct BabeConsensusDataProvider<B: BlockT, C> {
 
 	/// BABE config, gotten from the runtime.
 	config: Config,
+
+	/// Authorities to be used for this babe chain.
+	authorities: Vec<(AuthorityId, BabeAuthorityWeight)>,
 }
 
 impl<B, C> BabeConsensusDataProvider<B, C>
 	where
 		B: BlockT,
-		C: AuxStore + ProvideRuntimeApi<B>,
+		C: AuxStore + HeaderBackend<B> + ProvideRuntimeApi<B> + HeaderMetadata<B, Error = sp_blockchain::Error>,
 		C::Api: BabeApi<B, Error = sp_blockchain::Error>,
 {
 	pub fn new(
@@ -73,9 +79,14 @@ impl<B, C> BabeConsensusDataProvider<B, C>
 		keystore: SyncCryptoStorePtr,
 		provider: &InherentDataProviders,
 		epoch_changes: SharedEpochChanges<B, Epoch>,
+		authorities: Vec<(AuthorityId, BabeAuthorityWeight)>,
 	) -> Result<Self, Error> {
+		if authorities.is_empty() {
+			return Err(Error::StringError("Cannot supply empty authority set!".into()))
+		}
+
 		let config = Config::get_or_compute(&*client)?;
-		let timestamp_provider = SlotTimestampProvider::new(config.slot_duration)?;
+		let timestamp_provider = SlotTimestampProvider::new(client.clone())?;
 
 		provider.register_provider(timestamp_provider)?;
 		register_babe_inherent_data_provider(provider, config.slot_duration)?;
@@ -85,21 +96,11 @@ impl<B, C> BabeConsensusDataProvider<B, C>
 			client,
 			keystore,
 			epoch_changes,
+			authorities,
 		})
 	}
-}
-
-impl<B, C> ConsensusDataProvider<B> for BabeConsensusDataProvider<B, C>
-	where
-		B: BlockT,
-		C: AuxStore + HeaderBackend<B> + HeaderMetadata<B, Error = sp_blockchain::Error> + ProvideRuntimeApi<B>,
-		C::Api: BabeApi<B, Error = sp_blockchain::Error>,
-{
-	type Transaction = TransactionFor<C, B>;
-
-	fn create_digest(&self, parent: &B::Header, inherents: &InherentData) -> Result<DigestFor<B>, Error> {
-		let slot_number = inherents.babe_inherent_data()?;
 
+	fn epoch(&self, parent: &B::Header, slot_number: u64) -> Result<Epoch, Error> {
 		let epoch_changes = self.epoch_changes.lock();
 		let epoch_descriptor = epoch_changes
 			.epoch_descriptor_for_child_of(
@@ -121,15 +122,70 @@ impl<B, C> ConsensusDataProvider<B> for BabeConsensusDataProvider<B, C>
 				sp_consensus::Error::InvalidAuthoritiesSet
 			})?;
 
-		// this is a dev node environment, we should always be able to claim a slot.
-		let (predigest, _) = authorship::claim_slot(slot_number, epoch.as_ref(), &self.keystore)
-			.ok_or_else(|| Error::StringError("failed to claim slot for authorship".into()))?;
+		Ok(epoch.as_ref().clone())
+	}
+}
 
-		Ok(Digest {
-			logs: vec![
+impl<B, C> ConsensusDataProvider<B> for BabeConsensusDataProvider<B, C>
+	where
+		B: BlockT,
+		C: AuxStore + HeaderBackend<B> + HeaderMetadata<B, Error = sp_blockchain::Error> + ProvideRuntimeApi<B>,
+		C::Api: BabeApi<B, Error = sp_blockchain::Error>,
+{
+	type Transaction = TransactionFor<C, B>;
+
+	fn create_digest(&self, parent: &B::Header, inherents: &InherentData) -> Result<DigestFor<B>, Error> {
+		let slot_number = inherents.babe_inherent_data()?;
+		let epoch = self.epoch(parent, slot_number)?;
+
+		// this is a dev node environment, we should always be able to claim a slot.
+		let logs =  if let Some((predigest, _)) = authorship::claim_slot(slot_number, &epoch, &self.keystore) {
+			vec![
 				<DigestItemFor<B> as CompatibleDigestItem>::babe_pre_digest(predigest),
-			],
-		})
+			]
+		} else {
+			// well we couldn't claim a slot because this is an existing chain and we're not in the authorities.
+			// we need to tell BabeBlockImport that the epoch has changed, and we put ourselves in the authorities.
+			let predigest = PreDigest::SecondaryPlain(SecondaryPlainPreDigest {
+				slot_number,
+				authority_index: 0_u32,
+			});
+
+			let mut epoch_changes = self.epoch_changes.lock();
+			let epoch_descriptor = epoch_changes
+				.epoch_descriptor_for_child_of(
+					descendent_query(&*self.client),
+					&parent.hash(),
+					parent.number().clone(),
+					slot_number,
+				)
+				.map_err(|e| Error::StringError(format!("failed to fetch epoch_descriptor: {}", e)))?
+				.ok_or_else(|| sp_consensus::Error::InvalidAuthoritiesSet)?;
+
+			let epoch_mut = match epoch_descriptor {
+				ViableEpochDescriptor::Signaled(identifier, _epoch_header) => {
+					epoch_changes.epoch_mut(&identifier)
+						.ok_or_else(|| sp_consensus::Error::InvalidAuthoritiesSet)?
+				},
+				_ => unreachable!("we couldn't claim a slot, so this isn't the genesis epoch; qed")
+			};
+
+			// mutate the current epoch
+			epoch_mut.authorities = self.authorities.clone();
+
+			let next_epoch = ConsensusLog::NextEpochData(NextEpochDescriptor {
+				authorities: self.authorities.clone(),
+				// copy the old randomness
+				randomness: epoch_mut.randomness.clone(),
+			});
+
+			vec![
+				DigestItemFor::<B>::PreRuntime(BABE_ENGINE_ID, predigest.encode()),
+				DigestItemFor::<B>::Consensus(BABE_ENGINE_ID, next_epoch.encode())
+			]
+		};
+
+		Ok(Digest { logs })
 	}
 
 	fn append_block_import(
@@ -139,16 +195,42 @@ impl<B, C> ConsensusDataProvider<B> for BabeConsensusDataProvider<B, C>
 		inherents: &InherentData
 	) -> Result<(), Error> {
 		let slot_number = inherents.babe_inherent_data()?;
-
-		let epoch_descriptor = self.epoch_changes.lock()
+		let epoch_changes = self.epoch_changes.lock();
+		let mut epoch_descriptor = epoch_changes
 			.epoch_descriptor_for_child_of(
 				descendent_query(&*self.client),
 				&parent.hash(),
 				parent.number().clone(),
 				slot_number,
 			)
-			.map_err(|e| Error::StringError(format!("failed to fetch epoch data: {}", e)))?
+			.map_err(|e| Error::StringError(format!("failed to fetch epoch_descriptor: {}", e)))?
 			.ok_or_else(|| sp_consensus::Error::InvalidAuthoritiesSet)?;
+		// drop the lock
+		drop(epoch_changes);
+		// a quick check to see if we're in the authorities
+		let epoch = self.epoch(parent, slot_number)?;
+		let (authority, _) = self.authorities.first().expect("authorities is non-emptyp; qed");
+		let has_authority = epoch.authorities.iter()
+			.find(|(id, _)| *id == *authority)
+			.is_some();
+
+		if !has_authority {
+			log::info!(target: "manual-seal", "authority not found");
+			let slot_number = inherents.timestamp_inherent_data()? / self.config.slot_duration;
+			// manually hard code epoch descriptor
+			epoch_descriptor = match epoch_descriptor {
+				ViableEpochDescriptor::Signaled(identifier, _header) => {
+					ViableEpochDescriptor::Signaled(
+						identifier,
+						EpochHeader {
+							start_slot: slot_number,
+							end_slot: slot_number * self.config.epoch_length,
+						},
+					)
+				},
+				_ => unreachable!("we're not in the authorities, so this isn't the genesis epoch; qed")
+			};
+		}
 
 		params.intermediates.insert(
 			Cow::from(INTERMEDIATE_KEY),
@@ -168,12 +250,32 @@ struct SlotTimestampProvider {
 
 impl SlotTimestampProvider {
 	/// create a new mocked time stamp provider.
-	fn new(slot_duration: u64) -> Result<Self, Error> {
-		let now = SystemTime::now();
-		let duration = now.duration_since(SystemTime::UNIX_EPOCH)
-			.map_err(|err| Error::StringError(format!("{}", err)))?;
+	fn new<B, C>(client: Arc<C>) -> Result<Self, Error>
+		where
+			B: BlockT,
+			C: AuxStore + HeaderBackend<B> + ProvideRuntimeApi<B>,
+			C::Api: BabeApi<B, Error = sp_blockchain::Error>,
+	{
+		let slot_duration = Config::get_or_compute(&*client)?.slot_duration;
+		let info = client.info();
+
+		// looks like this isn't the first block, rehydrate the fake time.
+		// otherwise we'd be producing blocks for older slots.
+		let duration = if info.best_number != Zero::zero() {
+			let header = client.header(BlockId::Hash(info.best_hash))?.unwrap();
+			let slot_number = find_pre_digest::<B>(&header).unwrap().slot_number();
+			// add the slot duration so there's no collision of slots
+			(slot_number * slot_duration) + slot_duration
+		} else {
+			// this is the first block, use the correct time.
+			let now = SystemTime::now();
+			now.duration_since(SystemTime::UNIX_EPOCH)
+				.map_err(|err| Error::StringError(format!("{}", err)))?
+				.as_millis() as u64
+		};
+
 		Ok(Self {
-			time: atomic::AtomicU64::new(duration.as_millis() as u64),
+			time: atomic::AtomicU64::new(duration),
 			slot_duration,
 		})
 	}

substrate/client/executor/src/native_executor.rs

@@ -258,10 +258,10 @@ impl<D: NativeExecutionDispatch> NativeExecutor<D> {
 		default_heap_pages: Option<u64>,
 		max_runtime_instances: usize,
 	) -> Self {
-		let mut host_functions = sp_io::SubstrateHostFunctions::host_functions();
+		let mut host_functions = D::ExtendHostFunctions::host_functions();
 
 		// Add the custom host functions provided by the user.
-		host_functions.extend(D::ExtendHostFunctions::host_functions());
+		host_functions.extend(sp_io::SubstrateHostFunctions::host_functions());
 		let wasm_executor = WasmExecutor::new(
 			fallback_method,
 			default_heap_pages,

substrate/client/finality-grandpa/rpc/Cargo.toml

@@ -15,10 +15,10 @@ sp-blockchain = { version = "2.0.0", path = "../../../primitives/blockchain" }
 sp-core = { version = "2.0.0", path = "../../../primitives/core" }
 sp-runtime = { version = "2.0.0", path = "../../../primitives/runtime" }
 finality-grandpa = { version = "0.12.3", features = ["derive-codec"] }
-jsonrpc-core = "15.0.0"
-jsonrpc-core-client = "15.0.0"
-jsonrpc-derive = "15.0.0"
-jsonrpc-pubsub = "15.0.0"
+jsonrpc-core = "15.1.0"
+jsonrpc-core-client = "15.1.0"
+jsonrpc-derive = "15.1.0"
+jsonrpc-pubsub = "15.1.0"
 futures = { version = "0.3.4", features = ["compat"] }
 serde = { version = "1.0.105", features = ["derive"] }
 serde_json = "1.0.50"

substrate/client/rpc-api/Cargo.toml

@@ -16,10 +16,10 @@ targets = ["x86_64-unknown-linux-gnu"]
 codec = { package = "parity-scale-codec", version = "1.3.4" }
 derive_more = "0.99.2"
 futures = { version = "0.3.1", features = ["compat"] }
-jsonrpc-core = "15.0.0"
-jsonrpc-core-client = "15.0.0"
-jsonrpc-derive = "15.0.0"
-jsonrpc-pubsub = "15.0.0"
+jsonrpc-core = "15.1.0"
+jsonrpc-core-client = "15.1.0"
+jsonrpc-derive = "15.1.0"
+jsonrpc-pubsub = "15.1.0"
 log = "0.4.8"
 parking_lot = "0.10.0"
 sp-core = { version = "2.0.0", path = "../../primitives/core" }

substrate/client/rpc-servers/Cargo.toml

@@ -14,8 +14,8 @@ targets = ["x86_64-unknown-linux-gnu"]
 
 [dependencies]
 futures = "0.1.6"
-jsonrpc-core = "15.0.0"
-pubsub = { package = "jsonrpc-pubsub", version = "15.0.0" }
+jsonrpc-core = "15.1.0"
+pubsub = { package = "jsonrpc-pubsub", version = "15.1.0" }
 log = "0.4.8"
 prometheus-endpoint = { package = "substrate-prometheus-endpoint", path = "../../utils/prometheus", version = "0.8.0"}
 serde = "1.0.101"
@@ -23,6 +23,6 @@ serde_json = "1.0.41"
 sp-runtime = { version = "2.0.0", path = "../../primitives/runtime" }
 
 [target.'cfg(not(target_os = "unknown"))'.dependencies]
-http = { package = "jsonrpc-http-server", version = "15.0.0" }
-ipc = { package = "jsonrpc-ipc-server", version = "15.0.0" }
-ws = { package = "jsonrpc-ws-server", version = "15.0.0" }
+http = { package = "jsonrpc-http-server", version = "15.1.0" }
+ipc = { package = "jsonrpc-ipc-server", version = "15.1.0" }
+ws = { package = "jsonrpc-ws-server", version = "15.1.0" }

substrate/client/rpc/Cargo.toml

@@ -18,11 +18,10 @@ sc-client-api = { version = "2.0.0", path = "../api" }
 sp-api = { version = "2.0.0", path = "../../primitives/api" }
 codec = { package = "parity-scale-codec", version = "1.3.4" }
 futures = { version = "0.3.1", features = ["compat"] }
-jsonrpc-pubsub = "15.0.0"
+jsonrpc-pubsub = "15.1.0"
 log = "0.4.8"
 sp-core = { version = "2.0.0", path = "../../primitives/core" }
-sp-keystore = { version = "0.8.0", path = "../../primitives/keystore" }
-rpc = { package = "jsonrpc-core", version = "15.0.0" }
+rpc = { package = "jsonrpc-core", version = "15.1.0" }
 sp-version = { version = "2.0.0", path = "../../primitives/version" }
 serde_json = "1.0.41"
 sp-session = { version = "2.0.0", path = "../../primitives/session" }
@@ -30,6 +29,7 @@ sp-offchain = { version = "2.0.0", path = "../../primitives/offchain" }
 sp-runtime = { version = "2.0.0", path = "../../primitives/runtime" }
 sp-utils = { version = "2.0.0", path = "../../primitives/utils" }
 sp-rpc = { version = "2.0.0", path = "../../primitives/rpc" }
+sp-keystore = { version = "0.8.0", path = "../../primitives/keystore" }
 sp-state-machine = { version = "0.8.0", path = "../../primitives/state-machine" }
 sp-chain-spec = { version = "2.0.0", path = "../../primitives/chain-spec" }
 sc-executor = { version = "0.8.0", path = "../executor" }

substrate/client/service/Cargo.toml

@@ -27,8 +27,8 @@ test-helpers = []
 derive_more = "0.99.2"
 futures01 = { package = "futures", version = "0.1.29" }
 futures = { version = "0.3.4", features = ["compat"] }
-jsonrpc-pubsub = "15.0"
-jsonrpc-core = "15.0"
+jsonrpc-pubsub = "15.1"
+jsonrpc-core = "15.1"
 rand = "0.7.3"
 parking_lot = "0.10.0"
 lazy_static = "1.4.0"