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/Cargo.lock

@@ -2020,8 +2020,12 @@ dependencies = [
  "node-primitives 2.0.0",
  "node-runtime 2.0.0",
  "parity-codec 3.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rand 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
  "sr-io 2.0.0",
  "sr-primitives 2.0.0",
+ "srml-finality-tracker 2.0.0",
+ "srml-indices 2.0.0",
+ "srml-timestamp 2.0.0",
  "structopt 0.2.15 (registry+https://github.com/rust-lang/crates.io-index)",
  "substrate-basic-authorship 2.0.0",
  "substrate-cli 2.0.0",
@@ -2029,6 +2033,7 @@ dependencies = [
  "substrate-consensus-aura 2.0.0",
  "substrate-finality-grandpa 2.0.0",
  "substrate-inherents 2.0.0",
+ "substrate-keyring 2.0.0",
  "substrate-keystore 2.0.0",
  "substrate-network 2.0.0",
  "substrate-primitives 2.0.0",
@@ -2037,6 +2042,7 @@ dependencies = [
  "substrate-telemetry 2.0.0",
  "substrate-transaction-pool 2.0.0",
  "tokio 0.1.19 (registry+https://github.com/rust-lang/crates.io-index)",
+ "transaction-factory 0.0.1",
 ]
 
 [[package]]
@@ -4918,6 +4924,20 @@ name = "traitobject"
 version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
+[[package]]
+name = "transaction-factory"
+version = "0.0.1"
+dependencies = [
+ "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "parity-codec 3.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "sr-primitives 2.0.0",
+ "substrate-cli 2.0.0",
+ "substrate-client 2.0.0",
+ "substrate-consensus-common 2.0.0",
+ "substrate-primitives 2.0.0",
+ "substrate-service 2.0.0",
+]
+
 [[package]]
 name = "trie-bench"
 version = "0.12.2"

substrate/core/cli/src/lib.rs

@@ -49,10 +49,10 @@ use structopt::{StructOpt, clap::AppSettings};
 pub use structopt::clap::App;
 use params::{
 	RunCmd, PurgeChainCmd, RevertCmd, ImportBlocksCmd, ExportBlocksCmd, BuildSpecCmd,
-	NetworkConfigurationParams, SharedParams, MergeParameters, TransactionPoolParams,
+	NetworkConfigurationParams, MergeParameters, TransactionPoolParams,
 	NodeKeyParams, NodeKeyType
 };
-pub use params::{NoCustom, CoreParams};
+pub use params::{NoCustom, CoreParams, SharedParams};
 pub use traits::{GetLogFilter, AugmentClap};
 use app_dirs::{AppInfo, AppDataType};
 use log::info;
@@ -178,7 +178,7 @@ fn is_node_name_valid(_name: &str) -> Result<(), &str> {
 ///
 /// `CC` is a custom subcommand. This needs to be an `enum`! If no custom subcommand is required,
 /// `NoCustom` can be used as type here.
-/// `RP` is are custom parameters for the run command. This needs to be a `struct`! The custom
+/// `RP` are custom parameters for the run command. This needs to be a `struct`! The custom
 /// parameters are visible to the user as if they were normal run command parameters. If no custom
 /// parameters are required, `NoCustom` can be used as type here.
 pub fn parse_and_execute<'a, F, CC, RP, S, RS, E, I, T>(
@@ -582,7 +582,8 @@ where
 	Ok(())
 }
 
-fn create_config_with_db_path<F, S>(
+/// Creates a configuration including the database path.
+pub fn create_config_with_db_path<F, S>(
 	spec_factory: S, cli: &SharedParams, version: &VersionInfo,
 ) -> error::Result<FactoryFullConfiguration<F>>
 where

substrate/core/cli/src/traits.rs

@@ -16,7 +16,7 @@
 
 use structopt::{StructOpt, clap::App};
 
-/// Something that can augment a clapp app with further parameters.
+/// Something that can augment a clap app with further parameters.
 /// `derive(StructOpt)` is implementing this function by default, so a macro `impl_augment_clap!`
 /// is provided to simplify the implementation of this trait.
 pub trait AugmentClap: StructOpt {

substrate/core/consensus/common/src/lib.rs

@@ -39,7 +39,7 @@ pub use inherents::InherentData;
 
 pub mod offline_tracker;
 pub mod error;
-mod block_import;
+pub mod block_import;
 mod select_chain;
 pub mod import_queue;
 pub mod evaluation;

substrate/core/inherents/src/lib.rs

@@ -69,7 +69,7 @@ impl InherentData {
 	///
 	/// # Return
 	///
-	/// Returns `Ok(())` if the data could be inserted an no data for an inherent with the same
+	/// Returns `Ok(())` if the data could be inserted and no data for an inherent with the same
 	/// identifier existed, otherwise an error is returned.
 	///
 	/// Inherent identifiers need to be unique, otherwise decoding of these values will not work!

substrate/core/sr-primitives/src/generic/mod.rs

@@ -32,7 +32,7 @@ mod tests;
 pub use self::unchecked_extrinsic::UncheckedExtrinsic;
 pub use self::unchecked_mortal_extrinsic::UncheckedMortalExtrinsic;
 pub use self::unchecked_mortal_compact_extrinsic::UncheckedMortalCompactExtrinsic;
-pub use self::era::Era;
+pub use self::era::{Era, Phase};
 pub use self::checked_extrinsic::CheckedExtrinsic;
 pub use self::header::Header;
 pub use self::block::{Block, SignedBlock, BlockId};

substrate/node/cli/Cargo.toml

@@ -30,6 +30,13 @@ sr-primitives = { path = "../../core/sr-primitives" }
 node-executor = { path = "../executor" }
 substrate-keystore = { path = "../../core/keystore" }
 substrate-telemetry = { package = "substrate-telemetry", path = "../../core/telemetry" }
+structopt = "0.2"
+transaction-factory = { path = "../../test-utils/transaction-factory" }
+keyring = { package = "substrate-keyring", path = "../../core/keyring" }
+indices = { package = "srml-indices", path = "../../srml/indices" }
+timestamp = { package = "srml-timestamp", path = "../../srml/timestamp", default-features = false }
+rand = "0.6"
+finality_tracker = { package = "srml-finality-tracker", path = "../../srml/finality-tracker", default-features = false }
 
 [dev-dependencies]
 service-test = { package = "substrate-service-test", path = "../../core/service/test" }

substrate/node/cli/src/factory_impl.rs

@@ -0,0 +1,259 @@
+// 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/>.
+
+//! Implementation of the transaction factory trait, which enables
+//! using the cli to manufacture transactions and distribute them
+//! to accounts.
+
+use rand::{Rng, SeedableRng};
+use rand::rngs::StdRng;
+
+use parity_codec::Decode;
+use keyring::sr25519::Keyring;
+use node_primitives::Hash;
+use node_runtime::{Call, CheckedExtrinsic, UncheckedExtrinsic, BalancesCall};
+use primitives::sr25519;
+use primitives::crypto::Pair;
+use parity_codec::Encode;
+use sr_primitives::generic::Era;
+use sr_primitives::traits::{Block as BlockT, Header as HeaderT};
+use substrate_service::ServiceFactory;
+use transaction_factory::RuntimeAdapter;
+use transaction_factory::modes::Mode;
+use crate::service;
+use inherents::InherentData;
+use timestamp;
+use finality_tracker;
+
+// TODO get via api: <timestamp::Module<T>>::minimum_period(). See #2587.
+const MINIMUM_PERIOD: u64 = 99;
+
+pub struct FactoryState<N> {
+	block_no: N,
+
+	mode: Mode,
+	start_number: u64,
+	rounds: u64,
+	round: u64,
+	block_in_round: u64,
+	num: u64,
+}
+
+type Number = <<node_primitives::Block as BlockT>::Header as HeaderT>::Number;
+
+impl RuntimeAdapter for FactoryState<Number> {
+	type AccountId = node_primitives::AccountId;
+	type Balance = node_primitives::Balance;
+	type Block = node_primitives::Block;
+	type Phase = sr_primitives::generic::Phase;
+	type Secret = sr25519::Pair;
+	type Index = node_primitives::Index;
+
+	type Number = Number;
+
+	fn new(
+		mode: Mode,
+		num: u64,
+		rounds: u64,
+	) -> FactoryState<Self::Number> {
+		FactoryState {
+			mode,
+			num: num,
+			round: 0,
+			rounds,
+			block_in_round: 0,
+			block_no: 0,
+			start_number: 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 set_block_no(&mut self, val: Self::Number) {
+		self.block_no = val;
+	}
+
+	fn set_block_in_round(&mut self, val: Self::Number) {
+		self.block_in_round = val;
+	}
+
+	fn set_round(&mut self, val: Self::Number) {
+		self.round = val;
+	}
+
+	fn transfer_extrinsic(
+		&self,
+		sender: &Self::AccountId,
+		key: &Self::Secret,
+		destination: &Self::AccountId,
+		amount: &Self::Number,
+		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);
+
+		sign::<service::Factory, Self>(CheckedExtrinsic {
+			signed: Some((sender.clone(), index)),
+			function: Call::Balances(
+				BalancesCall::transfer(
+					indices::address::Address::Id(
+						destination.clone().into()
+					),
+					(*amount).into()
+				)
+			)
+		}, key, &prior_block_hash, phase)
+	}
+
+	fn inherent_extrinsics(&self) -> InherentData {
+		let timestamp = self.block_no * MINIMUM_PERIOD;
+
+		let mut inherent = InherentData::new();
+		inherent.put_data(timestamp::INHERENT_IDENTIFIER, &timestamp)
+			.expect("Failed putting timestamp inherent");
+		inherent.put_data(finality_tracker::INHERENT_IDENTIFIER, &self.block_no)
+			.expect("Failed putting finalized number inherent");
+		inherent
+	}
+
+	fn minimum_balance() -> Self::Number {
+		// TODO get correct amount via api. See #2587.
+		1337
+	}
+
+	fn master_account_id() -> Self::AccountId {
+		Keyring::Alice.pair().public()
+	}
+
+	fn master_account_secret() -> Self::Secret {
+		Keyring::Alice.pair()
+	}
+
+	/// 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));
+		pair.public().into()
+	}
+
+	/// 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));
+		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()
+		} else {
+			match self.round() {
+				0 =>
+					// if round is 0 all transactions will be done with master as a sender
+					self.block_no(),
+				_ =>
+					// 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
+	}
+}
+
+fn gen_seed_bytes(seed: u64) -> [u8; 32] {
+	let mut rng: StdRng = SeedableRng::seed_from_u64(seed);
+
+	let mut seed_bytes = [0u8; 32];
+	for i in 0..32 {
+		seed_bytes[i] = rng.gen::<u8>();
+	}
+	seed_bytes
+}
+
+/// Creates an `UncheckedExtrinsic` containing the appropriate signature for
+/// a `CheckedExtrinsics`.
+fn sign<F: ServiceFactory, RA: RuntimeAdapter>(
+	xt: CheckedExtrinsic,
+	key: &sr25519::Pair,
+	prior_block_hash: &Hash,
+	phase: u64,
+) -> <RA::Block as BlockT>::Extrinsic {
+	let s = match xt.signed {
+		Some((signed, index)) => {
+			let era = Era::mortal(256, phase);
+			let payload = (index.into(), xt.function, era, prior_block_hash);
+			let signature = payload.using_encoded(|b| {
+				if b.len() > 256 {
+					key.sign(&sr_io::blake2_256(b))
+				} else {
+					key.sign(b)
+				}
+			}).into();
+			UncheckedExtrinsic {
+				signature: Some((indices::address::Address::Id(signed), signature, payload.0, era)),
+				function: payload.1,
+			}
+		}
+		None => UncheckedExtrinsic {
+			signature: None,
+			function: xt.function,
+		},
+	};
+
+	let e = Encode::encode(&s);
+	Decode::decode(&mut &e[..]).expect("Failed to decode signed unchecked extrinsic")
+}

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>(

substrate/test-utils/transaction-factory/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "transaction-factory"
+version = "0.0.1"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2018"
+
+[dependencies]
+cli = { package = "substrate-cli", path = "../../core/cli" }
+client = { package = "substrate-client", path = "../../core/client" }
+consensus_common = { package = "substrate-consensus-common", path = "../../core/consensus/common" }
+log = "0.4"
+parity-codec = { version = "3.3", default-features = false, features = ["derive"] }
+primitives = { package = "substrate-primitives", path = "../../core/primitives", default-features = false }
+sr_primitives = { package = "sr-primitives", path = "../../core/sr-primitives", default-features = false }
+substrate-service = { path = "../../core/service" }
+
+[features]
+default = ["std"]
+std = [
+	"parity-codec/std",
+	"primitives/std",
+]

substrate/test-utils/transaction-factory/src/complex_mode.rs

@@ -0,0 +1,156 @@
+// 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::block_builder::api::BlockBuilder;
+use client::runtime_api::ConstructRuntimeApi;
+use sr_primitives::generic::BlockId;
+use sr_primitives::traits::{Block as BlockT, ProvideRuntimeApi, One, Zero};
+use substrate_service::{
+	FactoryBlock, FullClient, ServiceFactory, ComponentClient, FullComponents
+};
+
+use crate::{RuntimeAdapter, create_block};
+
+pub fn next<F, RA>(
+	factory_state: &mut RA,
+	client: &Arc<ComponentClient<FullComponents<F>>>,
+	prior_block_hash: <RA::Block as BlockT>::Hash,
+	prior_block_id: BlockId<F::Block>,
+) -> Option<<F as ServiceFactory>::Block>
+where
+	F: ServiceFactory,
+	F::RuntimeApi: ConstructRuntimeApi<FactoryBlock<F>, FullClient<F>>,
+	FullClient<F>: ProvideRuntimeApi,
+	<FullClient<F> as ProvideRuntimeApi>::Api: BlockBuilder<FactoryBlock<F>>,
+	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 mut amount;
+	if factory_state.round() == RA::Number::zero() {
+		amount = RA::minimum_balance() * factory_state.rounds();
+	} else {
+		let rounds_left = factory_state.rounds() - factory_state.round();
+		amount = RA::minimum_balance() * rounds_left;
+	};
+
+	let transfer = factory_state.transfer_extrinsic(
+		&from.0,
+		&from.1,
+		&to,
+		&amount,
+		&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::<F, 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/test-utils/transaction-factory/src/lib.rs

@@ -0,0 +1,179 @@
+// 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::ops::Mul;
+use std::cmp::PartialOrd;
+use std::fmt::Display;
+
+use log::info;
+
+use client::block_builder::api::BlockBuilder;
+use client::runtime_api::ConstructRuntimeApi;
+use consensus_common::{
+	BlockOrigin, ImportBlock, InherentData, ForkChoiceStrategy,
+	SelectChain
+};
+use consensus_common::block_import::BlockImport;
+use parity_codec::{Decode, Encode};
+use sr_primitives::generic::BlockId;
+use sr_primitives::traits::{
+	Block as BlockT, Header as HeaderT, ProvideRuntimeApi, SimpleArithmetic,
+	One, Zero,
+};
+use substrate_service::{
+	FactoryBlock, FactoryFullConfiguration, FullClient, new_client,
+	ServiceFactory, ComponentClient, FullComponents};
+pub use crate::modes::Mode;
+
+pub mod modes;
+mod complex_mode;
+mod simple_modes;
+
+pub trait RuntimeAdapter {
+	type AccountId: Display;
+	type Balance: Display + Mul;
+	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::Number,
+		prior_block_hash: &<Self::Block as BlockT>::Hash,
+	) -> <Self::Block as BlockT>::Extrinsic;
+
+	fn inherent_extrinsics(&self) -> InherentData;
+
+	fn minimum_balance() -> Self::Number;
+	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<F, RA>(
+	mut factory_state: RA,
+	mut config: FactoryFullConfiguration<F>,
+) -> cli::error::Result<()>
+where
+	F: ServiceFactory,
+	F::RuntimeApi: ConstructRuntimeApi<FactoryBlock<F>, FullClient<F>>,
+	FullClient<F>: ProvideRuntimeApi,
+	<FullClient<F> as ProvideRuntimeApi>::Api: BlockBuilder<FactoryBlock<F>>,
+	RA: RuntimeAdapter,
+	<<RA as RuntimeAdapter>::Block as BlockT>::Hash: From<primitives::H256>,
+{
+	if *factory_state.mode() != Mode::MasterToNToM && factory_state.rounds() > RA::Number::one() {
+		return Err("The factory can only be used with rounds set to 1 in this mode.".into());
+	}
+
+	let client = new_client::<F>(&config)?;
+
+	let select_chain = F::build_select_chain(&mut config, client.clone())?;
+
+	let best_header: Result<<F::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 best_block_id = BlockId::<F::Block>::hash(best_hash);
+
+	while let Some(block) = match factory_state.mode() {
+		Mode::MasterToNToM =>
+			complex_mode::next::<F, RA>(&mut factory_state, &client, best_hash.into(), best_block_id),
+		_ =>
+			simple_modes::next::<F, RA>(&mut factory_state, &client, best_hash.into(), best_block_id)
+	} {
+		best_hash = block.header().hash();
+		import_block::<F>(&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<F, RA>(
+	client: &Arc<ComponentClient<FullComponents<F>>>,
+	transfer: <RA::Block as BlockT>::Extrinsic,
+	inherent_extrinsics: Vec<<F::Block as BlockT>::Extrinsic>,
+) -> <F as ServiceFactory>::Block
+where
+	F: ServiceFactory,
+	FullClient<F>: ProvideRuntimeApi,
+	F::RuntimeApi: ConstructRuntimeApi<FactoryBlock<F>, FullClient<F>>,
+	<FullClient<F> as ProvideRuntimeApi>::Api: BlockBuilder<FactoryBlock<F>>,
+	RA: RuntimeAdapter,
+{
+	let mut block = client.new_block().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<F>(
+	client: &Arc<ComponentClient<FullComponents<F>>>,
+	block: <F as ServiceFactory>::Block
+) -> () where F: ServiceFactory
+{
+	let import = ImportBlock {
+		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,
+	};
+	client.import_block(import, HashMap::new()).expect("Failed to import block");
+}

substrate/test-utils/transaction-factory/src/modes.rs

@@ -0,0 +1,41 @@
+// 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/test-utils/transaction-factory/src/simple_modes.rs

@@ -0,0 +1,106 @@
+// 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::block_builder::api::BlockBuilder;
+use client::runtime_api::ConstructRuntimeApi;
+use sr_primitives::traits::{Block as BlockT, ProvideRuntimeApi, One};
+use sr_primitives::generic::BlockId;
+use substrate_service::{
+	FactoryBlock, FullClient, ServiceFactory, ComponentClient, FullComponents
+};
+
+use crate::{Mode, RuntimeAdapter, create_block};
+
+pub fn next<F, RA>(
+	factory_state: &mut RA,
+	client: &Arc<ComponentClient<FullComponents<F>>>,
+	prior_block_hash: <RA::Block as BlockT>::Hash,
+	prior_block_id: BlockId<F::Block>,
+) -> Option<<F as ServiceFactory>::Block>
+where
+	F: ServiceFactory,
+	F::RuntimeApi: ConstructRuntimeApi<FactoryBlock<F>, FullClient<F>>,
+	FullClient<F>: ProvideRuntimeApi,
+	<FullClient<F> as ProvideRuntimeApi>::Api: BlockBuilder<FactoryBlock<F>>,
+	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,
+		&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::<F, 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)
+}