Transaction factory (#2481)

* Fix typos

* Add transaction factory

`cargo run -- purge-chain -y --chain dev && cargo run -- --dev --transaction-factory 10`

* Fix comment and remove build deps

* Move crate to test-utils

* Switch from flag to subcommand

`cargo run -- factory --dev --num 5`

* Decouple factory from node specifics

* Introduce different manufacturing modes

* Remove unrelated changes

* Update Cargo.lock

* Use SelectChain to fetch best block

* Improve expect proof

* Panic if factory executed with unsupported chain spec

* Link ToDo comments to follow-up ticket

* Address comments and improve style

* Remove unused dependencies

* Fix indent level

* Replace naked unwrap

* Update node/cli/src/factory_impl.rs

* Fix typo

* Use inherent_extrinsics instead of timestamp

* Generalize factory and remove saturated conversions

* Format imports

* Make it clearer that database needs to be empty

* Ensure factory settings

* Apply suggestions from code review

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

* Update test-utils/transaction-factory/src/lib.rs

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

* Fix match guard syntax

* Simplify import, remove empty line

* Update node/cli/Cargo.toml

* Update lockfile

substrate/node/cli/src/lib.rs

@@ -22,16 +22,21 @@
 pub use cli::error;
 pub mod chain_spec;
 mod service;
+mod factory_impl;
 
 use tokio::prelude::Future;
 use tokio::runtime::{Builder as RuntimeBuilder, Runtime};
-pub use cli::{VersionInfo, IntoExit, NoCustom};
+pub use cli::{VersionInfo, IntoExit, NoCustom, SharedParams};
 use substrate_service::{ServiceFactory, Roles as ServiceRoles};
 use std::ops::Deref;
 use log::info;
+use structopt::{StructOpt, clap::App};
+use cli::{AugmentClap, GetLogFilter};
+use crate::factory_impl::FactoryState;
+use transaction_factory::RuntimeAdapter;
 
 /// The chain specification option.
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq)]
 pub enum ChainSpec {
 	/// Whatever the current runtime is, with just Alice as an auth.
 	Development,
@@ -43,6 +48,68 @@ pub enum ChainSpec {
 	StagingTestnet,
 }
 
+/// Custom subcommands.
+#[derive(Clone, Debug, StructOpt)]
+pub enum CustomSubcommands {
+	/// The custom factory subcommmand for manufacturing transactions.
+	#[structopt(
+		name = "factory",
+		about = "Manufactures num transactions from Alice to random accounts. \
+		Only supported for development or local testnet."
+	)]
+	Factory(FactoryCmd),
+}
+
+impl GetLogFilter for CustomSubcommands {
+	fn get_log_filter(&self) -> Option<String> {
+		None
+	}
+}
+
+/// The `factory` command used to generate transactions.
+/// 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,
+
+	/// 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: 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,
+
+	#[allow(missing_docs)]
+	#[structopt(flatten)]
+	pub shared_params: SharedParams,
+}
+
+impl AugmentClap for FactoryCmd {
+	fn augment_clap<'a, 'b>(app: App<'a, 'b>) -> App<'a, 'b> {
+		FactoryCmd::augment_clap(app)
+	}
+}
+
 /// Get a chain config from a spec setting.
 impl ChainSpec {
 	pub(crate) fn load(self) -> Result<chain_spec::ChainSpec, String> {
@@ -78,7 +145,7 @@ pub fn run<I, T, E>(args: I, exit: E, version: cli::VersionInfo) -> error::Resul
 	T: Into<std::ffi::OsString> + Clone,
 	E: IntoExit,
 {
-	cli::parse_and_execute::<service::Factory, NoCustom, NoCustom, _, _, _, _, _>(
+	let ret = cli::parse_and_execute::<service::Factory, CustomSubcommands, NoCustom, _, _, _, _, _>(
 		load_spec, &version, "substrate-node", args, exit,
 		|exit, _cli_args, _custom_args, config| {
 			info!("{}", version.name);
@@ -103,7 +170,35 @@ pub fn run<I, T, E>(args: I, exit: E, version: cli::VersionInfo) -> error::Resul
 				),
 			}.map_err(|e| format!("{:?}", e))
 		}
-	).map_err(Into::into).map(|_| ())
+	);
+
+	match &ret {
+		Ok(Some(CustomSubcommands::Factory(cli_args))) => {
+			let config = cli::create_config_with_db_path::<service::Factory, _>(
+				load_spec,
+				&cli_args.shared_params,
+				&version,
+			)?;
+
+			match ChainSpec::from(config.chain_spec.id()) {
+				Some(ref c) if c == &ChainSpec::Development || c == &ChainSpec::LocalTestnet => {},
+				_ => panic!("Factory is only supported for development and local testnet."),
+			}
+
+			let factory_state = FactoryState::new(
+				cli_args.mode.clone(),
+				cli_args.num,
+				cli_args.rounds,
+			);
+			transaction_factory::factory::<service::Factory, FactoryState<_>>(
+				factory_state,
+				config,
+			).map_err(|e| format!("Error in transaction factory: {}", e))?;
+
+			Ok(())
+		},
+		_ => ret.map_err(Into::into).map(|_| ())
+	}
 }
 
 fn run_until_exit<T, C, E>(