Chores/merge upstream

Cargo.toml

@@ -35,6 +35,7 @@ members = [
 	"client/executor/wasmtime",
 	"client/executor/runtime-test",
 	"client/finality-grandpa",
+	"client/informant",
 	"client/tracing",
 	"client/keystore",
 	"client/network",

bin/node-template/node/src/service.rs

@@ -159,7 +159,6 @@ pub fn new_full(config: Configuration<GenesisConfig>)
 				grandpa_link,
 				service.network(),
 				service.on_exit(),
-				service.spawn_task_handle(),
 			)?);
 		},
 		(true, false) => {
@@ -172,7 +171,6 @@ pub fn new_full(config: Configuration<GenesisConfig>)
 				on_exit: service.on_exit(),
 				telemetry_on_connect: Some(service.telemetry_on_connect_stream()),
 				voting_rule: grandpa::VotingRulesBuilder::default().build(),
-				executor: service.spawn_task_handle(),
 			};
 
 			// the GRANDPA voter task is considered infallible, i.e.

bin/node-template/runtime/src/lib.rs

@@ -12,7 +12,7 @@ use sp_std::prelude::*;
 use sp_core::OpaqueMetadata;
 use sp_runtime::{
 	ApplyExtrinsicResult, transaction_validity::TransactionValidity, generic, create_runtime_str,
-	impl_opaque_keys, MultiSignature
+	impl_opaque_keys, MultiSignature,
 };
 use sp_runtime::traits::{
 	BlakeTwo256, Block as BlockT, StaticLookup, Verify, ConvertInto, IdentifyAccount

bin/node/cli/browser-demo/index.html

@@ -15,11 +15,12 @@
 async function start() {
 	log('Loading WASM');
 	await init('./pkg/node_cli_bg.wasm');
-	log('Successfully loaded WASM');
+	log('Fetching chain spec');
+	const chain_spec_response = await fetch("https://raw.githubusercontent.com/paritytech/substrate/master/bin/node/cli/res/flaming-fir.json");
+	const chain_spec_text = await chain_spec_response.text();
 
 	// Build our client.
-	log('Starting client');
-	let client = await start_client(ws());
+	let client = await start_client(chain_spec_text, 'info', ws());
 	log('Client started');
 
 	client.rpcSubscribe('{"method":"chain_subscribeNewHead","params":[],"id":1,"jsonrpc":"2.0"}',

bin/node/cli/src/browser.rs

@@ -14,28 +14,28 @@
 // You should have received a copy of the GNU General Public License
 // along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
 
-use crate::ChainSpec;
+use crate::chain_spec::ChainSpec;
 use log::info;
 use wasm_bindgen::prelude::*;
 use sc_service::Configuration;
 use browser_utils::{
 	Transport, Client,
 	browser_configuration, set_console_error_panic_hook, init_console_log,
 };
+use std::str::FromStr;
 
 /// Starts the client.
 #[wasm_bindgen]
-pub async fn start_client(wasm_ext: Transport) -> Result<Client, JsValue> {
-	start_inner(wasm_ext)
+pub async fn start_client(chain_spec: String, log_level: String, wasm_ext: Transport) -> Result<Client, JsValue> {
+	start_inner(chain_spec, log_level, wasm_ext)
 		.await
 		.map_err(|err| JsValue::from_str(&err.to_string()))
 }
 
-async fn start_inner(wasm_ext: Transport) -> Result<Client, Box<dyn std::error::Error>> {
+async fn start_inner(chain_spec: String, log_level: String, wasm_ext: Transport) -> Result<Client, Box<dyn std::error::Error>> {
 	set_console_error_panic_hook();
-	init_console_log(log::Level::Info)?;
-
-	let chain_spec = ChainSpec::FlamingFir.load()
+	init_console_log(log::Level::from_str(&log_level)?)?;
+	let chain_spec = ChainSpec::from_json_bytes(chain_spec.as_bytes().to_vec())
 		.map_err(|e| format!("{:?}", e))?;
 
 	let config: Configuration<_, _> = browser_configuration(wasm_ext, chain_spec)

bin/node/cli/src/chain_spec.rs

@@ -257,13 +257,17 @@ pub fn testnet_genesis(
 		}),
 		pallet_democracy: Some(DemocracyConfig::default()),
 		pallet_collective_Instance1: Some(CouncilConfig {
-			members: endowed_accounts.iter().cloned()
-				.collect::<Vec<_>>()[..(num_endowed_accounts + 1) / 2].to_vec(),
+			members: endowed_accounts.iter()
+						.take((num_endowed_accounts + 1) / 2)
+						.cloned()
+						.collect(),
 			phantom: Default::default(),
 		}),
 		pallet_collective_Instance2: Some(TechnicalCommitteeConfig {
-			members: endowed_accounts.iter().cloned()
-				.collect::<Vec<_>>()[..(num_endowed_accounts + 1) / 2].to_vec(),
+			members: endowed_accounts.iter()
+						.take((num_endowed_accounts + 1) / 2)
+						.cloned()
+						.collect(),
 			phantom: Default::default(),
 		}),
 		pallet_contracts: Some(ContractsConfig {
@@ -291,7 +295,10 @@ pub fn testnet_genesis(
 		pallet_membership_Instance1: Some(Default::default()),
 		pallet_treasury: Some(Default::default()),
 		pallet_society: Some(SocietyConfig {
-			members: endowed_accounts[0..3].to_vec(),
+			members: endowed_accounts.iter()
+						.take((num_endowed_accounts + 1) / 2)
+						.cloned()
+						.collect(),
 			pot: 0,
 			max_members: 999,
 		}),
@@ -355,6 +362,7 @@ pub(crate) mod tests {
 	use super::*;
 	use crate::service::{new_full, new_light};
 	use sc_service_test;
+	use sp_runtime::BuildStorage;
 
 	fn local_testnet_genesis_instant_single() -> GenesisConfig {
 		testnet_genesis(
@@ -404,4 +412,19 @@ pub(crate) mod tests {
 			|config| new_light(config),
 		);
 	}
+
+	#[test]
+	fn test_create_development_chain_spec() {
+		development_config().build_storage().unwrap();
+	}
+
+	#[test]
+	fn test_create_local_testnet_chain_spec() {
+		local_testnet_config().build_storage().unwrap();
+	}
+
+	#[test]
+	fn test_staging_test_net_chain_spec() {
+		staging_testnet_config().build_storage().unwrap();
+	}
 }

bin/node/cli/src/cli.rs

@@ -52,34 +52,13 @@ pub enum Subcommand {
 /// Please note: this command currently only works on an empty database!
 #[derive(Debug, StructOpt, Clone)]
 pub struct FactoryCmd {
-	/// How often to repeat. This option only has an effect in mode `MasterToNToM`.
-	#[structopt(long="rounds", default_value = "1")]
-	pub rounds: u64,
+	/// Number of blocks to generate.
+	#[structopt(long="blocks", default_value = "1")]
+	pub blocks: u32,
 
-	/// MasterToN: Manufacture `num` transactions from the master account
-	///            to `num` randomly created accounts, one each.
-	///
-	/// MasterTo1: Manufacture `num` transactions from the master account
-	///            to exactly one other randomly created account.
-	///
-	/// MasterToNToM: Manufacture `num` transactions from the master account
-	///               to `num` randomly created accounts.
-	///               From each of these randomly created accounts manufacture
-	///               a transaction to another randomly created account.
-	///               Repeat this `rounds` times. If `rounds` = 1 the behavior
-	///               is the same as `MasterToN`.{n}
-	///               A -> B, A -> C, A -> D, ... x `num`{n}
-	///               B -> E, C -> F, D -> G, ...{n}
-	///               ... x `rounds`
-	///
-	/// These three modes control manufacturing.
-	#[structopt(long="mode", default_value = "MasterToN")]
-	pub mode: node_transaction_factory::Mode,
-
-	/// Number of transactions to generate. In mode `MasterNToNToM` this is
-	/// the number of transactions per round.
-	#[structopt(long="num", default_value = "8")]
-	pub num: u64,
+	/// Number of transactions to push per block.
+	#[structopt(long="transactions", default_value = "8")]
+	pub transactions: u32,
 
 	#[allow(missing_docs)]
 	#[structopt(flatten)]

bin/node/cli/src/command.rs

@@ -67,9 +67,8 @@ where
 			}
 
 			let factory_state = FactoryState::new(
-				cli_args.mode.clone(),
-				cli_args.num,
-				cli_args.rounds,
+				cli_args.blocks,
+				cli_args.transactions,
 			);
 
 			let service_builder = new_full_start!(config).0;

bin/node/cli/src/factory_impl.rs

@@ -33,22 +33,17 @@ use sp_runtime::{
 	generic::Era, traits::{Block as BlockT, Header as HeaderT, SignedExtension, Verify, IdentifyAccount}
 };
 use node_transaction_factory::RuntimeAdapter;
-use node_transaction_factory::modes::Mode;
 use sp_inherents::InherentData;
 use sp_timestamp;
 use sp_finality_tracker;
 
 type AccountPublic = <Signature as Verify>::Signer;
 
 pub struct FactoryState<N> {
-	block_no: N,
-
-	mode: Mode,
-	start_number: u32,
-	rounds: u32,
-	round: u32,
-	block_in_round: u32,
-	num: u32,
+	blocks: u32,
+	transactions: u32,
+	block_number: N,
+	index: u32,
 }
 
 type Number = <<node_primitives::Block as BlockT>::Header as HeaderT>::Number;
@@ -79,63 +74,35 @@ impl RuntimeAdapter for FactoryState<Number> {
 	type Number = Number;
 
 	fn new(
-		mode: Mode,
-		num: u64,
-		rounds: u64,
+		blocks: u32,
+		transactions: u32,
 	) -> FactoryState<Self::Number> {
 		FactoryState {
-			mode,
-			num: num as u32,
-			round: 0,
-			rounds: rounds as u32,
-			block_in_round: 0,
-			block_no: 0,
-			start_number: 0,
+			blocks,
+			transactions,
+			block_number: 0,
+			index: 0,
 		}
 	}
 
-	fn block_no(&self) -> Self::Number {
-		self.block_no
-	}
-
-	fn block_in_round(&self) -> Self::Number {
-		self.block_in_round
-	}
-
-	fn rounds(&self) -> Self::Number {
-		self.rounds
-	}
-
-	fn num(&self) -> Self::Number {
-		self.num
-	}
-
-	fn round(&self) -> Self::Number {
-		self.round
-	}
-
-	fn start_number(&self) -> Self::Number {
-		self.start_number
-	}
-
-	fn mode(&self) -> &Mode {
-		&self.mode
+	fn block_number(&self) -> u32 {
+		self.block_number
 	}
 
-	fn set_block_no(&mut self, val: Self::Number) {
-		self.block_no = val;
+	fn blocks(&self) -> u32 {
+		self.blocks
 	}
 
-	fn set_block_in_round(&mut self, val: Self::Number) {
-		self.block_in_round = val;
+	fn transactions(&self) -> u32 {
+		self.transactions
 	}
 
-	fn set_round(&mut self, val: Self::Number) {
-		self.round = val;
+	fn set_block_number(&mut self, value: u32) {
+		self.block_number = value;
 	}
 
 	fn transfer_extrinsic(
-		&self,
+		&mut self,
 		sender: &Self::AccountId,
 		key: &Self::Secret,
 		destination: &Self::AccountId,
@@ -144,10 +111,12 @@ impl RuntimeAdapter for FactoryState<Number> {
 		genesis_hash: &<Self::Block as BlockT>::Hash,
 		prior_block_hash: &<Self::Block as BlockT>::Hash,
 	) -> <Self::Block as BlockT>::Extrinsic {
-		let index = self.extract_index(&sender, prior_block_hash);
-		let phase = self.extract_phase(*prior_block_hash);
+		let phase = self.block_number() as Self::Phase;
+		let extra = Self::build_extra(self.index, phase);
+		self.index += 1;
+
 		sign::<Self>(CheckedExtrinsic {
-			signed: Some((sender.clone(), Self::build_extra(index, phase))),
+			signed: Some((sender.clone(), extra)),
 			function: Call::Balances(
 				BalancesCall::transfer(
 					pallet_indices::address::Address::Id(destination.clone().into()),
@@ -158,12 +127,12 @@ impl RuntimeAdapter for FactoryState<Number> {
 	}
 
 	fn inherent_extrinsics(&self) -> InherentData {
-		let timestamp = (self.block_no as u64 + 1) * MinimumPeriod::get();
+		let timestamp = (self.block_number as u64 + 1) * MinimumPeriod::get();
 
 		let mut inherent = InherentData::new();
 		inherent.put_data(sp_timestamp::INHERENT_IDENTIFIER, &timestamp)
 			.expect("Failed putting timestamp inherent");
-		inherent.put_data(sp_finality_tracker::INHERENT_IDENTIFIER, &self.block_no)
+		inherent.put_data(sp_finality_tracker::INHERENT_IDENTIFIER, &self.block_number)
 			.expect("Failed putting finalized number inherent");
 		inherent
 	}
@@ -181,49 +150,16 @@ impl RuntimeAdapter for FactoryState<Number> {
 	}
 
 	/// Generates a random `AccountId` from `seed`.
-	fn gen_random_account_id(seed: &Self::Number) -> Self::AccountId {
-		let pair: sr25519::Pair = sr25519::Pair::from_seed(&gen_seed_bytes(*seed));
+	fn gen_random_account_id(seed: u32) -> Self::AccountId {
+		let pair: sr25519::Pair = sr25519::Pair::from_seed(&gen_seed_bytes(seed));
 		AccountPublic::from(pair.public()).into_account()
 	}
 
 	/// Generates a random `Secret` from `seed`.
-	fn gen_random_account_secret(seed: &Self::Number) -> Self::Secret {
-		let pair: sr25519::Pair = sr25519::Pair::from_seed(&gen_seed_bytes(*seed));
+	fn gen_random_account_secret(seed: u32) -> Self::Secret {
+		let pair: sr25519::Pair = sr25519::Pair::from_seed(&gen_seed_bytes(seed));
 		pair
 	}
-
-	fn extract_index(
-		&self,
-		_account_id: &Self::AccountId,
-		_block_hash: &<Self::Block as BlockT>::Hash,
-	) -> Self::Index {
-		// TODO get correct index for account via api. See #2587.
-		// This currently prevents the factory from being used
-		// without a preceding purge of the database.
-		if self.mode == Mode::MasterToN || self.mode == Mode::MasterTo1 {
-			self.block_no() as Self::Index
-		} else {
-			match self.round() {
-				0 =>
-					// if round is 0 all transactions will be done with master as a sender
-					self.block_no() as Self::Index,
-				_ =>
-					// if round is e.g. 1 every sender account will be new and not yet have
-					// any transactions done
-					0
-			}
-		}
-	}
-
-	fn extract_phase(
-		&self,
-		_block_hash: <Self::Block as BlockT>::Hash
-	) -> Self::Phase {
-		// TODO get correct phase via api. See #2587.
-		// This currently prevents the factory from being used
-		// without a preceding purge of the database.
-		self.block_no() as Self::Phase
-	}
 }
 
 fn gen_seed_bytes(seed: u32) -> [u8; 32] {