Clean up crate names and locations (#4361)

* rename crate: sp-transaction-pool-api -> sp-transaction-pool

* move primitives/core/derive-debug -> primitives/derive-debug; primitives/core/storage -> primitives/storage

* rename crate sp-core-storage -> sp-storage

* rename and move: test/utils/transaction-factory -> client/transaction-factory

* move transaction-factory -> node/transaction-factory

* fix missing rename

* Move chain-spec-builder into bin/utils

* move subkey into bin/utils

* Update new subkey location

* Update docs to reflect new location for utils

* fixing import name

substrate/bin/node-template/Cargo.toml

@@ -25,7 +25,7 @@ sc-executor = { path = "../../client/executor" }
 sc-service = { path = "../../client/service" }
 inherents = { package = "sp-inherents", path = "../../primitives/inherents" }
 txpool = { package = "sc-transaction-pool", path = "../../client/transaction-pool" }
-txpool-api = { package = "sp-transaction-pool-api", path = "../../primitives/transaction-pool" }
+txpool-api = { package = "sp-transaction-pool", path = "../../primitives/transaction-pool" }
 network = { package = "sc-network", path = "../../client/network" }
 aura = { package = "sc-consensus-aura", path = "../../client/consensus/aura" }
 aura-primitives = { package = "sp-consensus-aura", path = "../../primitives/consensus/aura" }

substrate/bin/node-template/runtime/Cargo.toml

@@ -29,7 +29,7 @@ support = { package = "frame-support", path = "../../../frame/support", default-
 system = { package = "frame-system", path = "../../../frame/system", default-features = false }
 timestamp = { package = "pallet-timestamp", path = "../../../frame/timestamp", default-features = false }
 transaction-payment = { package = "pallet-transaction-payment", path = "../../../frame/transaction-payment", default-features = false }
-sp-transaction-pool = { package = "sp-transaction-pool-api", path = "../../../primitives/transaction-pool", default-features = false }
+sp-transaction-pool = { package = "sp-transaction-pool", path = "../../../primitives/transaction-pool", default-features = false }
 version = { package = "sp-version", path = "../../../primitives/version", default-features = false }
 
 [build-dependencies]

substrate/bin/node/cli/Cargo.toml

@@ -51,7 +51,7 @@ client-api = { package = "sc-client-api", path = "../../../client/api" }
 client = { package = "sc-client", path = "../../../client/" }
 chain-spec = { package = "sc-chain-spec", path = "../../../client/chain-spec" }
 txpool = { package = "sc-transaction-pool", path = "../../../client/transaction-pool" }
-txpool-api = { package = "sp-transaction-pool-api", path = "../../../primitives/transaction-pool" }
+txpool-api = { package = "sp-transaction-pool", path = "../../../primitives/transaction-pool" }
 network = { package = "sc-network", path = "../../../client/network" }
 babe = { package = "sc-consensus-babe", path = "../../../client/consensus/babe" }
 grandpa = { package = "sc-finality-grandpa", path = "../../../client/finality-grandpa" }
@@ -83,8 +83,8 @@ node-executor = { path = "../executor" }
 # CLI-specific dependencies
 tokio = { version = "0.1.22", optional = true }
 sc-cli = { path = "../../../client/cli", optional = true }
-transaction-factory = { path = "../../../test/utils/transaction-factory", optional = true }
 ctrlc = { version = "3.1.3", features = ["termination"], optional = true }
+node-transaction-factory = { path = "../transaction-factory", optional = true }
 
 # WASM-specific dependencies
 libp2p = { version = "0.13.0", default-features = false, optional = true }
@@ -126,7 +126,7 @@ browser = [
 ]
 cli = [
 	"sc-cli",
-	"transaction-factory",
+	"node-transaction-factory",
 	"tokio",
 	"ctrlc",
 	"sc-service/rocksdb",

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

@@ -24,7 +24,7 @@ use structopt::{StructOpt, clap::App};
 use sc_cli::{display_role, parse_and_prepare, AugmentClap, GetLogFilter, ParseAndPrepare};
 use crate::{service, ChainSpec, load_spec};
 use crate::factory_impl::FactoryState;
-use transaction_factory::RuntimeAdapter;
+use node_transaction_factory::RuntimeAdapter;
 
 /// Custom subcommands.
 #[derive(Clone, Debug, StructOpt)]
@@ -70,7 +70,7 @@ pub struct FactoryCmd {
 	///
 	/// These three modes control manufacturing.
 	#[structopt(long="mode", default_value = "MasterToN")]
-	pub mode: transaction_factory::Mode,
+	pub mode: node_transaction_factory::Mode,
 
 	/// Number of transactions to generate. In mode `MasterNToNToM` this is
 	/// the number of transactions per round.
@@ -155,7 +155,7 @@ pub fn run<I, T, E>(args: I, exit: E, version: sc_cli::VersionInfo) -> error::Re
 			);
 
 			let service_builder = new_full_start!(config).0;
-			transaction_factory::factory::<FactoryState<_>, _, _, _, _, _>(
+			node_transaction_factory::factory::<FactoryState<_>, _, _, _, _, _>(
 				factory_state,
 				service_builder.client(),
 				service_builder.select_chain()

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

@@ -32,8 +32,8 @@ use primitives::{sr25519, crypto::Pair};
 use sp_runtime::{
 	generic::Era, traits::{Block as BlockT, Header as HeaderT, SignedExtension, Verify, IdentifyAccount}
 };
-use transaction_factory::RuntimeAdapter;
-use transaction_factory::modes::Mode;
+use node_transaction_factory::RuntimeAdapter;
+use node_transaction_factory::modes::Mode;
 use inherents::InherentData;
 use sp_timestamp;
 use sp_finality_tracker;

substrate/bin/node/rpc/Cargo.toml

@@ -13,4 +13,4 @@ sp-runtime = { path = "../../../primitives/runtime" }
 pallet-contracts-rpc = { path = "../../../frame/contracts/rpc/" }
 pallet-transaction-payment-rpc = { path = "../../../frame/transaction-payment/rpc/" }
 substrate-frame-rpc-system = { path = "../../../utils/frame/rpc/system" }
-txpool-api = { package = "sp-transaction-pool-api", path = "../../../primitives/transaction-pool" }
+txpool-api = { package = "sp-transaction-pool", path = "../../../primitives/transaction-pool" }

substrate/bin/node/runtime/Cargo.toml

@@ -27,7 +27,7 @@ sp-runtime = { path = "../../../primitives/runtime", default-features = false }
 sp-staking = { path = "../../../primitives/staking", default-features = false }
 sp-keyring = { path = "../../../primitives/keyring", optional = true }
 sp-session = { path = "../../../primitives/session", default-features = false }
-sp-transaction-pool = { package = "sp-transaction-pool-api", path = "../../../primitives/transaction-pool", default-features = false }
+sp-transaction-pool = { package = "sp-transaction-pool", path = "../../../primitives/transaction-pool", default-features = false }
 version = { package = "sp-version", path = "../../../primitives/version", default-features = false }
 
 # frame dependencies

substrate/bin/node/transaction-factory/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "node-transaction-factory"
+version = "0.0.1"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2018"
+
+[dependencies]
+block-builder-api = { package = "sp-block-builder", path = "../../../primitives/block-builder" }
+cli = { package = "sc-cli", path = "../../../client/cli" }
+client-api = { package = "sc-client-api", path = "../../../client/api" }
+client = { package = "sc-client", path = "../../../client" }
+codec = { package = "parity-scale-codec", version = "1.0.0", features = ["derive"] }
+consensus_common = { package = "sp-consensus", path = "../../../primitives/consensus/common" }
+log = "0.4.8"
+primitives = { package = "sp-core", path = "../../../primitives/core" }
+sp-api = { path = "../../../primitives/api" }
+sp-runtime = { path = "../../../primitives/runtime" }
+sc-service = { path = "../../../client/service" }
+sp-blockchain = { path = "../../../primitives/blockchain" }

substrate/bin/node/transaction-factory/src/complex_mode.rs

@@ -0,0 +1,157 @@
+// 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/>.
+
+/// This module implements the `MasterToNToM` mode:
+///
+/// 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 round `rounds` times. If `rounds` = 1 the behavior
+/// is the same as `MasterToN`.
+///
+///   A -> B
+///   A -> C
+///   A -> D
+///   ... x `num`
+///
+///   B -> E
+///   C -> F
+///   D -> G
+///   ...
+///   E -> H
+///   F -> I
+///   G -> J
+///   ...
+///   ... x `rounds`
+
+use std::sync::Arc;
+
+use log::info;
+use client::Client;
+use block_builder_api::BlockBuilder;
+use sp_api::ConstructRuntimeApi;
+use primitives::{Blake2Hasher, Hasher};
+use sp_runtime::generic::BlockId;
+use sp_runtime::traits::{Block as BlockT, ProvideRuntimeApi, One, Zero};
+
+use crate::{RuntimeAdapter, create_block};
+
+pub fn next<RA, Backend, Exec, Block, RtApi>(
+	factory_state: &mut RA,
+	client: &Arc<Client<Backend, Exec, Block, RtApi>>,
+	version: u32,
+	genesis_hash: <RA::Block as BlockT>::Hash,
+	prior_block_hash: <RA::Block as BlockT>::Hash,
+	prior_block_id: BlockId<Block>,
+) -> Option<Block>
+where
+	Block: BlockT<Hash = <Blake2Hasher as Hasher>::Out>,
+	Exec: client::CallExecutor<Block, Blake2Hasher> + Send + Sync + Clone,
+	Backend: client_api::backend::Backend<Block, Blake2Hasher> + Send,
+	Client<Backend, Exec, Block, RtApi>: ProvideRuntimeApi,
+	<Client<Backend, Exec, Block, RtApi> as ProvideRuntimeApi>::Api:
+		BlockBuilder<Block, Error = sp_blockchain::Error>,
+	RtApi: ConstructRuntimeApi<Block, Client<Backend, Exec, Block, RtApi>> + Send + Sync,
+	RA: RuntimeAdapter,
+{
+	let total = factory_state.start_number() + factory_state.num() * factory_state.rounds();
+
+	if factory_state.block_no() >= total || factory_state.round() >= factory_state.rounds() {
+		return None;
+	}
+
+	info!(
+		"Round {}: Creating {} transactions in total, {} per round. {} rounds in total.",
+		factory_state.round() + RA::Number::one(),
+		factory_state.num() * factory_state.rounds(),
+		factory_state.num(),
+		factory_state.rounds(),
+	);
+
+	let from = from::<RA>(factory_state);
+
+	let seed = factory_state.start_number() + factory_state.block_no();
+	let to = RA::gen_random_account_id(&seed);
+
+	let rounds_left = factory_state.rounds() - factory_state.round();
+	let amount = RA::minimum_balance() * rounds_left.into();
+
+	let transfer = factory_state.transfer_extrinsic(
+		&from.0,
+		&from.1,
+		&to,
+		&amount,
+		version,
+		&genesis_hash,
+		&prior_block_hash,
+	);
+
+	let inherents = factory_state.inherent_extrinsics();
+	let inherents = client.runtime_api().inherent_extrinsics(&prior_block_id, inherents)
+		.expect("Failed to create inherent extrinsics");
+
+	let block = create_block::<RA, _, _, _, _>(&client, transfer, inherents);
+	info!(
+		"Created block {} with hash {}. Transferring {} from {} to {}.",
+		factory_state.block_no() + RA::Number::one(),
+		prior_block_hash,
+		amount,
+		from.0,
+		to
+	);
+
+	factory_state.set_block_no(factory_state.block_no() + RA::Number::one());
+
+	let new_round = factory_state.block_no() > RA::Number::zero()
+		&& factory_state.block_no() % factory_state.num() == RA::Number::zero();
+	if new_round {
+		factory_state.set_round(factory_state.round() + RA::Number::one());
+		factory_state.set_block_in_round(RA::Number::zero());
+	} else {
+		factory_state.set_block_in_round(factory_state.block_in_round() + RA::Number::one());
+	}
+
+	Some(block)
+}
+
+/// Return the account which received tokens at this point in the previous round.
+fn from<RA>(
+	factory_state: &mut RA
+) -> (<RA as RuntimeAdapter>::AccountId, <RA as RuntimeAdapter>::Secret)
+where RA: RuntimeAdapter
+{
+	let is_first_round = factory_state.round() == RA::Number::zero();
+	match is_first_round {
+		true => {
+			// first round always uses master account
+			(RA::master_account_id(), RA::master_account_secret())
+		},
+		_ => {
+			// the account to which was sent in the last round
+			let is_round_one = factory_state.round() == RA::Number::one();
+			let seed = match is_round_one {
+				true => factory_state.start_number() + factory_state.block_in_round(),
+				_ => {
+					let block_no_in_prior_round =
+						factory_state.num() * (factory_state.round() - RA::Number::one()) + factory_state.block_in_round();
+					factory_state.start_number() + block_no_in_prior_round
+				}
+			};
+			(RA::gen_random_account_id(&seed), RA::gen_random_account_secret(&seed))
+		},
+	}
+}

substrate/bin/node/transaction-factory/src/lib.rs

@@ -0,0 +1,205 @@
+// 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/>.
+
+//! Simple transaction factory which distributes tokens from a master
+//! account to a specified number of newly created accounts.
+//!
+//! The factory currently only works on an empty database!
+
+use std::collections::HashMap;
+use std::sync::Arc;
+use std::cmp::PartialOrd;
+use std::fmt::Display;
+
+use log::info;
+
+use client::Client;
+use block_builder_api::BlockBuilder;
+use sp_api::ConstructRuntimeApi;
+use consensus_common::{
+	BlockOrigin, BlockImportParams, InherentData, ForkChoiceStrategy,
+	SelectChain
+};
+use consensus_common::block_import::BlockImport;
+use codec::{Decode, Encode};
+use primitives::{Blake2Hasher, Hasher};
+use sp_runtime::generic::BlockId;
+use sp_runtime::traits::{
+	Block as BlockT, Header as HeaderT, ProvideRuntimeApi, SimpleArithmetic,
+	One, Zero,
+};
+pub use crate::modes::Mode;
+
+pub mod modes;
+mod complex_mode;
+mod simple_modes;
+
+pub trait RuntimeAdapter {
+	type AccountId: Display;
+	type Balance: Display + SimpleArithmetic + From<Self::Number>;
+	type Block: BlockT;
+	type Index: Copy;
+	type Number: Display + PartialOrd + SimpleArithmetic + Zero + One;
+	type Phase: Copy;
+	type Secret;
+
+	fn new(mode: Mode, rounds: u64, start_number: u64) -> Self;
+
+	fn block_no(&self) -> Self::Number;
+	fn block_in_round(&self) -> Self::Number;
+	fn mode(&self) -> &Mode;
+	fn num(&self) -> Self::Number;
+	fn rounds(&self) -> Self::Number;
+	fn round(&self) -> Self::Number;
+	fn start_number(&self) -> Self::Number;
+
+	fn set_block_in_round(&mut self, val: Self::Number);
+	fn set_block_no(&mut self, val: Self::Number);
+	fn set_round(&mut self, val: Self::Number);
+
+	fn transfer_extrinsic(
+		&self,
+		sender: &Self::AccountId,
+		key: &Self::Secret,
+		destination: &Self::AccountId,
+		amount: &Self::Balance,
+		version: u32,
+		genesis_hash: &<Self::Block as BlockT>::Hash,
+		prior_block_hash: &<Self::Block as BlockT>::Hash,
+	) -> <Self::Block as BlockT>::Extrinsic;
+
+	fn inherent_extrinsics(&self) -> InherentData;
+
+	fn minimum_balance() -> Self::Balance;
+	fn master_account_id() -> Self::AccountId;
+	fn master_account_secret() -> Self::Secret;
+	fn extract_index(&self, account_id: &Self::AccountId, block_hash: &<Self::Block as BlockT>::Hash) -> Self::Index;
+	fn extract_phase(&self, block_hash: <Self::Block as BlockT>::Hash) -> Self::Phase;
+	fn gen_random_account_id(seed: &Self::Number) -> Self::AccountId;
+	fn gen_random_account_secret(seed: &Self::Number) -> Self::Secret;
+}
+
+/// Manufactures transactions. The exact amount depends on
+/// `mode`, `num` and `rounds`.
+pub fn factory<RA, Backend, Exec, Block, RtApi, Sc>(
+	mut factory_state: RA,
+	client: &Arc<Client<Backend, Exec, Block, RtApi>>,
+	select_chain: &Sc,
+) -> cli::error::Result<()>
+where
+	Block: BlockT<Hash = <Blake2Hasher as Hasher>::Out>,
+	Exec: client::CallExecutor<Block, Blake2Hasher> + Send + Sync + Clone,
+	Backend: client_api::backend::Backend<Block, Blake2Hasher> + Send,
+	Client<Backend, Exec, Block, RtApi>: ProvideRuntimeApi,
+	<Client<Backend, Exec, Block, RtApi> as ProvideRuntimeApi>::Api:
+		BlockBuilder<Block, Error = sp_blockchain::Error>,
+	RtApi: ConstructRuntimeApi<Block, Client<Backend, Exec, Block, RtApi>> + Send + Sync,
+	Sc: SelectChain<Block>,
+	RA: RuntimeAdapter,
+	<<RA as RuntimeAdapter>::Block as BlockT>::Hash: From<primitives::H256>,
+{
+	if *factory_state.mode() != Mode::MasterToNToM && factory_state.rounds() > RA::Number::one() {
+		let msg = "The factory can only be used with rounds set to 1 in this mode.".into();
+		return Err(cli::error::Error::Input(msg));
+	}
+
+	let best_header: Result<<Block as BlockT>::Header, cli::error::Error> =
+		select_chain.best_chain().map_err(|e| format!("{:?}", e).into());
+	let mut best_hash = best_header?.hash();
+	let mut best_block_id = BlockId::<Block>::hash(best_hash);
+	let version = client.runtime_version_at(&best_block_id)?.spec_version;
+	let genesis_hash = client.block_hash(Zero::zero())?
+		.expect("Genesis block always exists; qed").into();
+
+	while let Some(block) = match factory_state.mode() {
+		Mode::MasterToNToM => complex_mode::next::<RA, _, _, _, _>(
+			&mut factory_state,
+			&client,
+			version,
+			genesis_hash,
+			best_hash.into(),
+			best_block_id,
+		),
+		_ => simple_modes::next::<RA, _, _, _, _>(
+			&mut factory_state,
+			&client,
+			version,
+			genesis_hash,
+			best_hash.into(),
+			best_block_id,
+		),
+	} {
+		best_hash = block.header().hash();
+		best_block_id = BlockId::<Block>::hash(best_hash);
+		import_block(&client, block);
+
+		info!("Imported block at {}", factory_state.block_no());
+	}
+
+	Ok(())
+}
+
+/// Create a baked block from a transfer extrinsic and timestamp inherent.
+pub fn create_block<RA, Backend, Exec, Block, RtApi>(
+	client: &Arc<Client<Backend, Exec, Block, RtApi>>,
+	transfer: <RA::Block as BlockT>::Extrinsic,
+	inherent_extrinsics: Vec<<Block as BlockT>::Extrinsic>,
+) -> Block
+where
+	Block: BlockT<Hash = <Blake2Hasher as Hasher>::Out>,
+	Exec: client::CallExecutor<Block, Blake2Hasher> + Send + Sync + Clone,
+	Backend: client_api::backend::Backend<Block, Blake2Hasher> + Send,
+	Client<Backend, Exec, Block, RtApi>: ProvideRuntimeApi,
+	RtApi: ConstructRuntimeApi<Block, Client<Backend, Exec, Block, RtApi>> + Send + Sync,
+	<Client<Backend, Exec, Block, RtApi> as ProvideRuntimeApi>::Api:
+		BlockBuilder<Block, Error = sp_blockchain::Error>,
+	RA: RuntimeAdapter,
+{
+	let mut block = client.new_block(Default::default()).expect("Failed to create new block");
+	block.push(
+		Decode::decode(&mut &transfer.encode()[..])
+			.expect("Failed to decode transfer extrinsic")
+	).expect("Failed to push transfer extrinsic into block");
+
+	for inherent in inherent_extrinsics {
+		block.push(inherent).expect("Failed ...");
+	}
+
+	block.bake().expect("Failed to bake block")
+}
+
+fn import_block<Backend, Exec, Block, RtApi>(
+	client: &Arc<Client<Backend, Exec, Block, RtApi>>,
+	block: Block
+) -> () where
+	Block: BlockT<Hash = <Blake2Hasher as Hasher>::Out>,
+	Exec: client::CallExecutor<Block, Blake2Hasher> + Send + Sync + Clone,
+	Backend: client_api::backend::Backend<Block, Blake2Hasher> + Send,
+{
+	let import = BlockImportParams {
+		origin: BlockOrigin::File,
+		header: block.header().clone(),
+		post_digests: Vec::new(),
+		body: Some(block.extrinsics().to_vec()),
+		finalized: false,
+		justification: None,
+		auxiliary: Vec::new(),
+		fork_choice: ForkChoiceStrategy::LongestChain,
+		allow_missing_state: false,
+		import_existing: false,
+	};
+	(&**client).import_block(import, HashMap::new()).expect("Failed to import block");
+}

substrate/bin/node/transaction-factory/src/modes.rs

@@ -0,0 +1,40 @@
+// 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/>.
+
+//! The transaction factory can operate in different modes. See
+//! the `simple_mode` and `complex_mode` modules for details.
+
+use std::str::FromStr;
+
+/// Token distribution modes.
+#[derive(Debug, Clone, PartialEq)]
+pub enum Mode {
+	MasterToN,
+	MasterTo1,
+	MasterToNToM
+}
+
+impl FromStr for Mode {
+	type Err = String;
+	fn from_str(mode: &str) -> Result<Self, Self::Err> {
+		match mode {
+			"MasterToN" => Ok(Mode::MasterToN),
+			"MasterTo1" => Ok(Mode::MasterTo1),
+			"MasterToNToM" => Ok(Mode::MasterToNToM),
+			_ => Err(format!("Invalid mode: {}", mode)),
+		}
+	}
+}

substrate/bin/node/transaction-factory/src/simple_modes.rs

@@ -0,0 +1,112 @@
+// 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/>.
+
+/// This module implements two manufacturing modes:
+///
+/// # MasterToN
+/// Manufacture `num` transactions from the master account
+/// to `num` randomly created accounts, one each.
+///
+///   A -> B
+///   A -> C
+///   ... x `num`
+///
+///
+/// # MasterTo1
+/// Manufacture `num` transactions from the master account
+/// to exactly one other randomly created account.
+///
+///   A -> B
+///   A -> B
+///   ... x `num`
+
+use std::sync::Arc;
+
+use log::info;
+use client::Client;
+use block_builder_api::BlockBuilder;
+use sp_api::ConstructRuntimeApi;
+use primitives::{Blake2Hasher, Hasher};
+use sp_runtime::traits::{Block as BlockT, ProvideRuntimeApi, One};
+use sp_runtime::generic::BlockId;
+
+use crate::{Mode, RuntimeAdapter, create_block};
+
+pub fn next<RA, Backend, Exec, Block, RtApi>(
+	factory_state: &mut RA,
+	client: &Arc<Client<Backend, Exec, Block, RtApi>>,
+	version: u32,
+	genesis_hash: <RA::Block as BlockT>::Hash,
+	prior_block_hash: <RA::Block as BlockT>::Hash,
+	prior_block_id: BlockId<Block>,
+) -> Option<Block>
+where
+	Block: BlockT<Hash = <Blake2Hasher as Hasher>::Out>,
+	Exec: client::CallExecutor<Block, Blake2Hasher> + Send + Sync + Clone,
+	Backend: client_api::backend::Backend<Block, Blake2Hasher> + Send,
+	Client<Backend, Exec, Block, RtApi>: ProvideRuntimeApi,
+	<Client<Backend, Exec, Block, RtApi> as ProvideRuntimeApi>::Api:
+		BlockBuilder<Block, Error = sp_blockchain::Error>,
+	RtApi: ConstructRuntimeApi<Block, Client<Backend, Exec, Block, RtApi>> + Send + Sync,
+	RA: RuntimeAdapter,
+{
+	if factory_state.block_no() >= factory_state.num() {
+		return None;
+	}
+
+	let from = (RA::master_account_id(), RA::master_account_secret());
+
+	let seed = match factory_state.mode() {
+		// choose the same receiver for all transactions
+		Mode::MasterTo1 => factory_state.start_number(),
+
+		// different receiver for each transaction
+		Mode::MasterToN => factory_state.start_number() + factory_state.block_no(),
+		_ => unreachable!("Mode not covered!"),
+	};
+	let to = RA::gen_random_account_id(&seed);
+
+	let amount = RA::minimum_balance();
+
+	let transfer = factory_state.transfer_extrinsic(
+		&from.0,
+		&from.1,
+		&to,
+		&amount,
+		version,
+		&genesis_hash,
+		&prior_block_hash,
+	);
+
+	let inherents = RA::inherent_extrinsics(&factory_state);
+	let inherents = client.runtime_api().inherent_extrinsics(&prior_block_id, inherents)
+		.expect("Failed to create inherent extrinsics");
+
+	let block = create_block::<RA, _, _, _, _>(&client, transfer, inherents);
+
+	factory_state.set_block_no(factory_state.block_no() + RA::Number::one());
+
+	info!(
+		"Created block {} with hash {}. Transferring {} from {} to {}.",
+		factory_state.block_no(),
+		prior_block_hash,
+		amount,
+		from.0,
+		to
+	);
+
+	Some(block)
+}

substrate/bin/utils/chain-spec-builder/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "chain-spec-builder"
+version = "2.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2018"
+build = "build.rs"
+
+[dependencies]
+ansi_term = "0.12.1"
+keystore = { package = "sc-keystore", path = "../../../client/keystore" }
+node-cli = { path = "../../node/cli" }
+primitives = { package = "sp-core",  path = "../../../primitives/core" }
+rand = "0.7.2"
+structopt = "0.3.3"

substrate/bin/utils/chain-spec-builder/build.rs

@@ -0,0 +1,23 @@
+// 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/>.
+
+use std::env;
+
+fn main() {
+	if let Ok(profile) = env::var("PROFILE") {
+		println!("cargo:rustc-cfg=build_type=\"{}\"", profile);
+	}
+}

substrate/bin/utils/chain-spec-builder/src/main.rs

@@ -0,0 +1,273 @@
+// 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/>.
+
+use std::{fs, path::{Path, PathBuf}};
+
+use ansi_term::Style;
+use rand::{Rng, distributions::Alphanumeric, rngs::OsRng};
+use structopt::StructOpt;
+
+use keystore::{Store as Keystore};
+use node_cli::chain_spec::{self, AccountId};
+use primitives::{sr25519, crypto::{Public, Ss58Codec}, traits::BareCryptoStore};
+
+/// A utility to easily create a testnet chain spec definition with a given set
+/// of authorities and endowed accounts and/or generate random accounts.
+#[derive(StructOpt)]
+#[structopt(rename_all = "kebab-case")]
+enum ChainSpecBuilder {
+	/// Create a new chain spec with the given authorities, endowed and sudo
+	/// accounts.
+	New {
+		/// Authority key seed.
+		#[structopt(long, short, required = true)]
+		authority_seeds: Vec<String>,
+		/// Endowed account address (SS58 format).
+		#[structopt(long, short)]
+		endowed_accounts: Vec<String>,
+		/// Sudo account address (SS58 format).
+		#[structopt(long, short)]
+		sudo_account: String,
+		/// The path where the chain spec should be saved.
+		#[structopt(long, short, default_value = "./chain_spec.json")]
+		chain_spec_path: PathBuf,
+	},
+	/// Create a new chain spec with the given number of authorities and endowed
+	/// accounts. Random keys will be generated as required.
+	Generate {
+		/// The number of authorities.
+		#[structopt(long, short)]
+		authorities: usize,
+		/// The number of endowed accounts.
+		#[structopt(long, short, default_value = "0")]
+		endowed: usize,
+		/// The path where the chain spec should be saved.
+		#[structopt(long, short, default_value = "./chain_spec.json")]
+		chain_spec_path: PathBuf,
+		/// Path to use when saving generated keystores for each authority.
+		///
+		/// At this path, a new folder will be created for each authority's
+		/// keystore named `auth-$i` where `i` is the authority index, i.e.
+		/// `auth-0`, `auth-1`, etc.
+		#[structopt(long, short)]
+		keystore_path: Option<PathBuf>,
+	},
+}
+
+impl ChainSpecBuilder {
+	/// Returns the path where the chain spec should be saved.
+	fn chain_spec_path(&self) -> &Path {
+		match self {
+			ChainSpecBuilder::New { chain_spec_path, .. } =>
+				chain_spec_path.as_path(),
+			ChainSpecBuilder::Generate { chain_spec_path, .. } =>
+				chain_spec_path.as_path(),
+		}
+	}
+}
+
+fn genesis_constructor(
+	authority_seeds: &[String],
+	endowed_accounts: &[AccountId],
+	sudo_account: &AccountId,
+) -> chain_spec::GenesisConfig {
+	let authorities = authority_seeds
+		.iter()
+		.map(AsRef::as_ref)
+		.map(chain_spec::get_authority_keys_from_seed)
+		.collect::<Vec<_>>();
+
+	let enable_println = true;
+
+	chain_spec::testnet_genesis(
+		authorities,
+		sudo_account.clone(),
+		Some(endowed_accounts.to_vec()),
+		enable_println,
+	)
+}
+
+fn generate_chain_spec(
+	authority_seeds: Vec<String>,
+	endowed_accounts: Vec<String>,
+	sudo_account: String,
+) -> Result<String, String> {
+	let parse_account = |address: &String| {
+		AccountId::from_string(address)
+			.map_err(|err| format!("Failed to parse account address: {:?}", err))
+	};
+
+	let endowed_accounts = endowed_accounts
+		.iter()
+		.map(parse_account)
+		.collect::<Result<Vec<_>, String>>()?;
+
+	let sudo_account = parse_account(&sudo_account)?;
+
+	let chain_spec = chain_spec::ChainSpec::from_genesis(
+		"Custom",
+		"custom",
+		move || genesis_constructor(&authority_seeds, &endowed_accounts, &sudo_account),
+		vec![],
+		None,
+		None,
+		None,
+		Default::default(),
+	);
+
+	chain_spec.to_json(false).map_err(|err| err.to_string())
+}
+
+fn generate_authority_keys_and_store(
+	seeds: &[String],
+	keystore_path: &Path,
+) -> Result<(), String> {
+	for (n, seed) in seeds.into_iter().enumerate() {
+		let keystore = Keystore::open(
+			keystore_path.join(format!("auth-{}", n)),
+			None,
+		).map_err(|err| err.to_string())?;
+
+		let (_, _, grandpa, babe, im_online, authority_discovery) =
+			chain_spec::get_authority_keys_from_seed(seed);
+
+		let insert_key = |key_type, public| {
+			keystore.write().insert_unknown(
+				key_type,
+				&format!("//{}", seed),
+				public,
+			).map_err(|_| format!("Failed to insert key: {}", grandpa))
+		};
+
+		insert_key(
+			primitives::crypto::key_types::BABE,
+			babe.as_slice(),
+		)?;
+
+		insert_key(
+			primitives::crypto::key_types::GRANDPA,
+			grandpa.as_slice(),
+		)?;
+
+		insert_key(
+			primitives::crypto::key_types::IM_ONLINE,
+			im_online.as_slice(),
+		)?;
+
+		insert_key(
+			primitives::crypto::key_types::AUTHORITY_DISCOVERY,
+			authority_discovery.as_slice(),
+		)?;
+	}
+
+	Ok(())
+}
+
+fn print_seeds(
+	authority_seeds: &[String],
+	endowed_seeds: &[String],
+	sudo_seed: &str,
+) {
+	let header = Style::new().bold().underline();
+	let entry = Style::new().bold();
+
+	println!("{}", header.paint("Authority seeds"));
+
+	for (n, seed) in authority_seeds.iter().enumerate() {
+		println!("{} //{}",
+			entry.paint(format!("auth-{}:", n)),
+			seed,
+		);
+	}
+
+	println!();
+
+	if !endowed_seeds.is_empty() {
+		println!("{}", header.paint("Endowed seeds"));
+		for (n, seed) in endowed_seeds.iter().enumerate() {
+			println!("{} //{}",
+				entry.paint(format!("endowed-{}:", n)),
+				seed,
+			);
+		}
+
+		println!();
+	}
+
+	println!("{}", header.paint("Sudo seed"));
+	println!("//{}", sudo_seed);
+}
+
+fn main() -> Result<(), String> {
+	#[cfg(build_type="debug")]
+	println!(
+		"The chain spec builder builds a chain specification that includes a Substrate runtime compiled as WASM. To \
+		 ensure proper functioning of the included runtime compile (or run) the chain spec builder binary in \
+		 `--release` mode.\n",
+	);
+
+	let builder = ChainSpecBuilder::from_args();
+	let chain_spec_path = builder.chain_spec_path().to_path_buf();
+
+	let (authority_seeds, endowed_accounts, sudo_account) = match builder {
+		ChainSpecBuilder::Generate { authorities, endowed, keystore_path, .. } => {
+			let authorities = authorities.max(1);
+			let rand_str = || -> String {
+				OsRng.sample_iter(&Alphanumeric)
+					.take(32)
+					.collect()
+			};
+
+			let authority_seeds = (0..authorities).map(|_| rand_str()).collect::<Vec<_>>();
+			let endowed_seeds = (0..endowed).map(|_| rand_str()).collect::<Vec<_>>();
+			let sudo_seed = rand_str();
+
+			print_seeds(
+				&authority_seeds,
+				&endowed_seeds,
+				&sudo_seed,
+			);
+
+			if let Some(keystore_path) = keystore_path {
+				generate_authority_keys_and_store(
+					&authority_seeds,
+					&keystore_path,
+				)?;
+			}
+
+			let endowed_accounts = endowed_seeds.iter().map(|seed| {
+				chain_spec::get_account_id_from_seed::<sr25519::Public>(seed)
+					.to_ss58check()
+			}).collect();
+
+			let sudo_account = chain_spec::get_account_id_from_seed::<sr25519::Public>(&sudo_seed)
+				.to_ss58check();
+
+			(authority_seeds, endowed_accounts, sudo_account)
+		},
+		ChainSpecBuilder::New { authority_seeds, endowed_accounts, sudo_account, .. } => {
+			(authority_seeds, endowed_accounts, sudo_account)
+		},
+	};
+
+	let json = generate_chain_spec(
+		authority_seeds,
+		endowed_accounts,
+		sudo_account,
+	)?;
+
+	fs::write(chain_spec_path, json).map_err(|err| err.to_string())
+}

substrate/bin/utils/subkey/Cargo.toml

@@ -5,10 +5,10 @@ authors = ["Parity Technologies <admin@parity.io>"]
 edition = "2018"
 
 [dependencies]
-primitives = { package = "sp-core",  version = "*", path = "../../primitives/core" }
-node-runtime = { version = "*", path = "../node/runtime" }
-node-primitives = { version = "*", path = "../node/primitives" }
-sp-runtime = { version = "*", path = "../../primitives/runtime" }
+primitives = { package = "sp-core",  version = "*", path = "../../../primitives/core" }
+node-runtime = { version = "*", path = "../../node/runtime" }
+node-primitives = { version = "*", path = "../../node/primitives" }
+sp-runtime = { version = "*", path = "../../../primitives/runtime" }
 rand = "0.7.2"
 clap = "2.33.0"
 tiny-bip39 = "0.6.2"
@@ -17,9 +17,9 @@ substrate-bip39 = "0.3.1"
 hex = "0.4.0"
 hex-literal = "0.2.1"
 codec = { package = "parity-scale-codec", version = "1.0.0" }
-system = { package = "frame-system", path = "../../frame/system" }
-balances = { package = "pallet-balances", path = "../../frame/balances" }
-transaction-payment = { package = "pallet-transaction-payment", path = "../../frame/transaction-payment" }
+system = { package = "frame-system", path = "../../../frame/system" }
+balances = { package = "pallet-balances", path = "../../../frame/balances" }
+transaction-payment = { package = "pallet-transaction-payment", path = "../../../frame/transaction-payment" }
 
 [features]
 bench = []