Make node-template in sync with node. (#3422)

* Make node-template in sync with node. * Update service.rs * Updated babe constants. * Added SignedExtra for CheckVersion in node-template and subkey. * Added CheckVersion SignedExtra for node. * Fixed tests. * Try fix integration test. * Attempt 2 at fixing integration test. * Update node-template/runtime/src/lib.rs
2026-04-26 20:27:58 +00:00 · 2019-08-19 09:17:33 +02:00
parent 8eacdb54de
commit 0bb44f5024
15 changed files with 456 additions and 181 deletions
@@ -1,9 +1,10 @@
-use primitives::{sr25519, Pair};
+use primitives::{Pair, Public};
 use node_template_runtime::{
-	AccountId, GenesisConfig, AuraConfig, BalancesConfig,
-	SudoConfig, IndicesConfig, SystemConfig, WASM_BINARY, AuraId
+	AccountId, BabeConfig, BalancesConfig, GenesisConfig, GrandpaConfig,
+	SudoConfig, IndicesConfig, SystemConfig, WASM_BINARY, 
 };
-use aura_primitives::sr25519::AuthorityPair as AuraPair;
+use babe_primitives::{AuthorityId as BabeId};
+use grandpa_primitives::{AuthorityId as GrandpaId};
 use substrate_service;

 // Note this is the URL for the telemetry server
@@ -23,16 +24,21 @@ pub enum Alternative {
 	LocalTestnet,
 }

-fn authority_key(s: &str) -> AuraId {
-	AuraPair::from_string(&format!("//{}", s), None)
+/// Helper function to generate a crypto pair from seed
+pub fn get_from_seed<TPublic: Public>(seed: &str) -> <TPublic::Pair as Pair>::Public {
+	TPublic::Pair::from_string(&format!("//{}", seed), None)
 		.expect("static values are valid; qed")
 		.public()
 }

-fn account_key(s: &str) -> AccountId {
-	sr25519::Pair::from_string(&format!("//{}", s), None)
-		.expect("static values are valid; qed")
-		.public()
+/// Helper function to generate stash, controller and session key from seed
+pub fn get_authority_keys_from_seed(seed: &str) -> (AccountId, AccountId, GrandpaId, BabeId) {
+	(
+		get_from_seed::<AccountId>(&format!("{}//stash", seed)),
+		get_from_seed::<AccountId>(seed),
+		get_from_seed::<GrandpaId>(seed),
+		get_from_seed::<BabeId>(seed),
+	)
 }

 impl Alternative {
@@ -43,12 +49,16 @@ impl Alternative {
 				"Development",
 				"dev",
 				|| testnet_genesis(vec![
-					authority_key("Alice")
-				], vec![
-					account_key("Alice")
+					get_authority_keys_from_seed("Alice"),
 				],
-					account_key("Alice")
-				),
+				get_from_seed::<AccountId>("Alice"),
+				vec![
+					get_from_seed::<AccountId>("Alice"),
+					get_from_seed::<AccountId>("Bob"),
+					get_from_seed::<AccountId>("Alice//stash"),
+					get_from_seed::<AccountId>("Bob//stash"),
+				],
+				true),
 				vec![],
 				None,
 				None,
@@ -59,18 +69,25 @@ impl Alternative {
 				"Local Testnet",
 				"local_testnet",
 				|| testnet_genesis(vec![
-					authority_key("Alice"),
-					authority_key("Bob"),
-				], vec![
-					account_key("Alice"),
-					account_key("Bob"),
-					account_key("Charlie"),
-					account_key("Dave"),
-					account_key("Eve"),
-					account_key("Ferdie"),
+					get_authority_keys_from_seed("Alice"),
+					get_authority_keys_from_seed("Bob"),
+				], 
+				get_from_seed::<AccountId>("Alice"),
+				vec![
+					get_from_seed::<AccountId>("Alice"),
+					get_from_seed::<AccountId>("Bob"),
+					get_from_seed::<AccountId>("Charlie"),
+					get_from_seed::<AccountId>("Dave"),
+					get_from_seed::<AccountId>("Eve"),
+					get_from_seed::<AccountId>("Ferdie"),
+					get_from_seed::<AccountId>("Alice//stash"),
+					get_from_seed::<AccountId>("Bob//stash"),
+					get_from_seed::<AccountId>("Charlie//stash"),
+					get_from_seed::<AccountId>("Dave//stash"),
+					get_from_seed::<AccountId>("Eve//stash"),
+					get_from_seed::<AccountId>("Ferdie//stash"),
 				],
-					account_key("Alice"),
-				),
+				true),
 				vec![],
 				None,
 				None,
@@ -89,15 +106,15 @@ impl Alternative {
 	}
 }

-fn testnet_genesis(initial_authorities: Vec<AuraId>, endowed_accounts: Vec<AccountId>, root_key: AccountId) -> GenesisConfig {
+fn testnet_genesis(initial_authorities: Vec<(AccountId, AccountId, GrandpaId, BabeId)>,
+	root_key: AccountId, 
+	endowed_accounts: Vec<AccountId>,
+	_enable_println: bool) -> GenesisConfig {
 	GenesisConfig {
 		system: Some(SystemConfig {
 			code: WASM_BINARY.to_vec(),
 			changes_trie_config: Default::default(),
 		}),
-		aura: Some(AuraConfig {
-			authorities: initial_authorities.clone(),
-		}),
 		indices: Some(IndicesConfig {
 			ids: endowed_accounts.clone(),
 		}),
@@ -108,5 +125,11 @@ fn testnet_genesis(initial_authorities: Vec<AuraId>, endowed_accounts: Vec<Accou
 		sudo: Some(SudoConfig {
 			key: root_key,
 		}),
+		babe: Some(BabeConfig {
+			authorities: initial_authorities.iter().map(|x| (x.3.clone(), 1)).collect(),
+		}),
+		grandpa: Some(GrandpaConfig {
+			authorities: initial_authorities.iter().map(|x| (x.2.clone(), 1)).collect(),
+		}),
 	}
 }
@@ -1,26 +1,26 @@
-//! Service and ServiceFactory implementation. Specialized wrapper over Substrate service.
-
 #![warn(unused_extern_crates)]

+//! Service and ServiceFactory implementation. Specialized wrapper over substrate service.
+
 use std::sync::Arc;
-use transaction_pool::{self, txpool::{Pool as TransactionPool}};
+use std::time::Duration;
+use substrate_client::{self as client, LongestChain};
+use babe::{import_queue, start_babe, BabeImportQueue, Config};
+use grandpa::{self, FinalityProofProvider as GrandpaFinalityProofProvider};
+use futures::prelude::*;
 use node_template_runtime::{self, GenesisConfig, opaque::Block, RuntimeApi, WASM_BINARY};
 use substrate_service::{
 	FactoryFullConfiguration, LightComponents, FullComponents, FullBackend,
 	FullClient, LightClient, LightBackend, FullExecutor, LightExecutor,
 	error::{Error as ServiceError},
 };
-use basic_authorship::ProposerFactory;
-use consensus::{import_queue, start_aura, AuraImportQueue, SlotDuration};
-use futures::prelude::*;
-use substrate_client::{self as client, LongestChain};
+use transaction_pool::{self, txpool::{Pool as TransactionPool}};
 use inherents::InherentDataProviders;
-use network::{config::DummyFinalityProofRequestBuilder, construct_simple_protocol};
+use network::construct_simple_protocol;
 use substrate_executor::native_executor_instance;
-use substrate_service::construct_service_factory;
-use aura_primitives::sr25519::AuthorityPair as AuraAuthorityPair;
-
+use substrate_service::{ServiceFactory, construct_service_factory, TelemetryOnConnect};
 pub use substrate_executor::NativeExecutor;
+
 // Our native executor instance.
 native_executor_instance!(
 	pub Executor,
@@ -29,62 +29,168 @@ native_executor_instance!(
 	WASM_BINARY
 );

-#[derive(Default)]
-pub struct NodeConfig {
-	inherent_data_providers: InherentDataProviders,
-}
-
 construct_simple_protocol! {
 	/// Demo protocol attachment for substrate.
 	pub struct NodeProtocol where Block = Block { }
 }

+type BabeBlockImportForService<F> = babe::BabeBlockImport<
+	FullBackend<F>,
+	FullExecutor<F>,
+	<F as ServiceFactory>::Block,
+	grandpa::BlockImportForService<F>,
+	<F as ServiceFactory>::RuntimeApi,
+	client::Client<
+		FullBackend<F>,
+		FullExecutor<F>,
+		<F as ServiceFactory>::Block,
+		<F as ServiceFactory>::RuntimeApi
+	>,
+>;
+
+pub struct NodeConfig<F: ServiceFactory> {
+	/// GRANDPA and BABE connection to import block.
+	// FIXME #1134 rather than putting this on the config, let's have an actual intermediate setup state
+	pub import_setup: Option<(
+		BabeBlockImportForService<F>,
+		grandpa::LinkHalfForService<F>,
+		babe::BabeLink,
+	)>,
+	/// Tasks that were created by previous setup steps and should be spawned.
+	pub tasks_to_spawn: Option<Vec<Box<dyn Future<Item = (), Error = ()> + Send>>>,
+	inherent_data_providers: InherentDataProviders,
+}
+
+impl<F> Default for NodeConfig<F> where F: ServiceFactory {
+	fn default() -> NodeConfig<F> {
+		NodeConfig {
+			import_setup: None,
+			inherent_data_providers: InherentDataProviders::new(),
+			tasks_to_spawn: None,
+		}
+	}
+}
+
 construct_service_factory! {
 	struct Factory {
 		Block = Block,
 		RuntimeApi = RuntimeApi,
 		NetworkProtocol = NodeProtocol { |config| Ok(NodeProtocol::new()) },
 		RuntimeDispatch = Executor,
-		FullTransactionPoolApi = transaction_pool::ChainApi<
-			client::Client<FullBackend<Self>, FullExecutor<Self>, Block, RuntimeApi>,
-			Block
-		> {
-			|config, client| Ok(TransactionPool::new(config, transaction_pool::ChainApi::new(client)))
-		},
-		LightTransactionPoolApi = transaction_pool::ChainApi<
-			client::Client<LightBackend<Self>, LightExecutor<Self>, Block, RuntimeApi>,
-			Block
-		> {
-			|config, client| Ok(TransactionPool::new(config, transaction_pool::ChainApi::new(client)))
-		},
-		Genesis = GenesisConfig,
-		Configuration = NodeConfig,
-		FullService = FullComponents<Self>
-			{ |config: FactoryFullConfiguration<Self>|
-				FullComponents::<Factory>::new(config)
+		FullTransactionPoolApi =
+			transaction_pool::ChainApi<
+				client::Client<FullBackend<Self>, FullExecutor<Self>, Block, RuntimeApi>,
+				Block
+			> {
+				|config, client|
+					Ok(TransactionPool::new(config, transaction_pool::ChainApi::new(client)))
 			},
+		LightTransactionPoolApi =
+			transaction_pool::ChainApi<
+				client::Client<LightBackend<Self>, LightExecutor<Self>, Block, RuntimeApi>,
+				Block
+			> {
+				|config, client|
+					Ok(TransactionPool::new(config, transaction_pool::ChainApi::new(client)))
+			},
+		Genesis = GenesisConfig,
+		Configuration = NodeConfig<Self>,
+		FullService = FullComponents<Self> {
+			|config: FactoryFullConfiguration<Self>| FullComponents::<Factory>::new(config)
+		},
 		AuthoritySetup = {
-			|service: Self::FullService| {
+			|mut service: Self::FullService| {
+				let (block_import, link_half, babe_link) =
+					service.config_mut().custom.import_setup.take()
+						.expect("Link Half and Block Import are present for Full Services or setup failed before. qed");
+
+				// spawn any futures that were created in the previous setup steps
+				if let Some(tasks) = service.config_mut().custom.tasks_to_spawn.take() {
+					for task in tasks {
+						service.spawn_task(
+							task.select(service.on_exit())
+								.map(|_| ())
+								.map_err(|_| ())
+						);
+					}
+				}
+
 				if service.config().roles.is_authority() {
-					let proposer = ProposerFactory {
+					let proposer = basic_authorship::ProposerFactory {
 						client: service.client(),
 						transaction_pool: service.transaction_pool(),
 					};
+
 					let client = service.client();
 					let select_chain = service.select_chain()
-						.ok_or_else(|| ServiceError::SelectChainRequired)?;
-					let aura = start_aura::<_, _, _, _, _, AuraAuthorityPair, _, _, _>(
-						SlotDuration::get_or_compute(&*client)?,
-						client.clone(),
-						select_chain,
+						.ok_or(ServiceError::SelectChainRequired)?;
+
+					let babe_config = babe::BabeParams {
+						config: Config::get_or_compute(&*client)?,
+						keystore: service.keystore(),
 						client,
-						proposer,
-						service.network(),
-						service.config().custom.inherent_data_providers.clone(),
-						service.config().force_authoring,
-						Some(service.keystore()),
-					)?;
-					service.spawn_task(Box::new(aura.select(service.on_exit()).then(|_| Ok(()))));
+						select_chain,
+						block_import,
+						env: proposer,
+						sync_oracle: service.network(),
+						inherent_data_providers: service.config()
+							.custom.inherent_data_providers.clone(),
+						force_authoring: service.config().force_authoring,
+						time_source: babe_link,
+					};
+
+					let babe = start_babe(babe_config)?;
+					let select = babe.select(service.on_exit()).then(|_| Ok(()));
+
+					// the BABE authoring task is considered infallible, i.e. if it
+					// fails we take down the service with it.
+					service.spawn_essential_task(select);
+				}
+
+				let config = grandpa::Config {
+					// FIXME #1578 make this available through chainspec
+					gossip_duration: Duration::from_millis(333),
+					justification_period: 4096,
+					name: Some(service.config().name.clone()),
+					keystore: Some(service.keystore()),
+				};
+
+				match (service.config().roles.is_authority(), service.config().disable_grandpa) {
+					(false, false) => {
+						// start the lightweight GRANDPA observer
+						service.spawn_task(Box::new(grandpa::run_grandpa_observer(
+							config,
+							link_half,
+							service.network(),
+							service.on_exit(),
+						)?));
+					},
+					(true, false) => {
+						// start the full GRANDPA voter
+						let telemetry_on_connect = TelemetryOnConnect {
+							telemetry_connection_sinks: service.telemetry_on_connect_stream(),
+						};
+						let grandpa_config = grandpa::GrandpaParams {
+							config: config,
+							link: link_half,
+							network: service.network(),
+							inherent_data_providers:
+								service.config().custom.inherent_data_providers.clone(),
+							on_exit: service.on_exit(),
+							telemetry_on_connect: Some(telemetry_on_connect),
+						};
+
+						// the GRANDPA voter task is considered infallible, i.e.
+						// if it fails we take down the service with it.
+						service.spawn_essential_task(grandpa::run_grandpa_voter(grandpa_config)?);
+					},
+					(_, true) => {
+						grandpa::setup_disabled_grandpa(
+							service.client(),
+							&service.config().custom.inherent_data_providers,
+							service.network(),
+						)?;
+					},
 				}

 				Ok(service)
@@ -92,50 +198,70 @@ construct_service_factory! {
 		},
 		LightService = LightComponents<Self>
 			{ |config| <LightComponents<Factory>>::new(config) },
-		FullImportQueue = AuraImportQueue<
-			Self::Block,
-		>
-			{ |
+		FullImportQueue = BabeImportQueue<Self::Block> {
+			|
 				config: &mut FactoryFullConfiguration<Self>,
 				client: Arc<FullClient<Self>>,
-				_select_chain: Self::SelectChain,
+				select_chain: Self::SelectChain,
 				transaction_pool: Option<Arc<TransactionPool<Self::FullTransactionPoolApi>>>,
 			| {
-					import_queue::<_, _, aura_primitives::sr25519::AuthorityPair, _>(
-						SlotDuration::get_or_compute(&*client)?,
-						Box::new(client.clone()),
-						None,
-						None,
-						client,
-						config.custom.inherent_data_providers.clone(),
-						transaction_pool,
-					).map_err(Into::into)
-				}
-			},
-		LightImportQueue = AuraImportQueue<
-			Self::Block,
-		>
-			{ |config: &mut FactoryFullConfiguration<Self>, client: Arc<LightClient<Self>>| {
-					let fprb = Box::new(DummyFinalityProofRequestBuilder::default()) as Box<_>;
-					import_queue::<_, _, AuraAuthorityPair, TransactionPool<Self::FullTransactionPoolApi>>(
-						SlotDuration::get_or_compute(&*client)?,
-						Box::new(client.clone()),
-						None,
-						None,
-						client,
-						config.custom.inherent_data_providers.clone(),
-						None,
-					).map(|q| (q, fprb)).map_err(Into::into)
-				}
-			},
+				let (block_import, link_half) =
+					grandpa::block_import::<_, _, _, RuntimeApi, FullClient<Self>, _>(
+						client.clone(), client.clone(), select_chain
+					)?;
+				let justification_import = block_import.clone();
+				let (import_queue, babe_link, babe_block_import, pruning_task) = import_queue(
+					Config::get_or_compute(&*client)?,
+					block_import,
+					Some(Box::new(justification_import)),
+					None,
+					client.clone(),
+					client,
+					config.custom.inherent_data_providers.clone(),
+					transaction_pool,
+				)?;
+				config.custom.import_setup = Some((babe_block_import.clone(), link_half, babe_link));
+				config.custom.tasks_to_spawn = Some(vec![Box::new(pruning_task)]);
+				Ok(import_queue)
+			}
+		},
+		LightImportQueue = BabeImportQueue<Self::Block>
+			{ |config: &FactoryFullConfiguration<Self>, client: Arc<LightClient<Self>>| {
+				#[allow(deprecated)]
+				let fetch_checker = client.backend().blockchain().fetcher()
+					.upgrade()
+					.map(|fetcher| fetcher.checker().clone())
+					.ok_or_else(|| "Trying to start light import queue without active fetch checker")?;
+				let block_import = grandpa::light_block_import::<_, _, _, RuntimeApi, LightClient<Self>>(
+					client.clone(), Arc::new(fetch_checker), client.clone()
+				)?;
+
+				let finality_proof_import = block_import.clone();
+				let finality_proof_request_builder =
+					finality_proof_import.create_finality_proof_request_builder();
+
+				// FIXME: pruning task isn't started since light client doesn't do `AuthoritySetup`.
+				let (import_queue, ..) = import_queue::<_, _, _, _, _, _, TransactionPool<Self::FullTransactionPoolApi>>(
+					Config::get_or_compute(&*client)?,
+					block_import,
+					None,
+					Some(Box::new(finality_proof_import)),
+					client.clone(),
+					client,
+					config.custom.inherent_data_providers.clone(),
+					None,
+				)?;
+
+				Ok((import_queue, finality_proof_request_builder))
+			}},
 		SelectChain = LongestChain<FullBackend<Self>, Self::Block>
 			{ |config: &FactoryFullConfiguration<Self>, client: Arc<FullClient<Self>>| {
 				#[allow(deprecated)]
 				Ok(LongestChain::new(client.backend().clone()))
 			}
 		},
-		FinalityProofProvider = { |_client: Arc<FullClient<Self>>| {
-			Ok(None)
+		FinalityProofProvider = { |client: Arc<FullClient<Self>>| {
+			Ok(Some(Arc::new(GrandpaFinalityProofProvider::new(client.clone(), client)) as _))
 		}},
 	}
 }