From a90b4fdb8c04dc9ed25e9c896edd185407496a74 Mon Sep 17 00:00:00 2001
From: Marcio Diaz <marcio.diaz@gmail.com>
Date: Tue, 11 Feb 2020 13:59:52 +0100
Subject: [PATCH] Refactor tx factory 1 (#4870)
* Remove modes.
* Refactor.
---
substrate/bin/node/cli/src/cli.rs | 33 +---
substrate/bin/node/cli/src/command.rs | 5 +-
substrate/bin/node/cli/src/factory_impl.rs | 124 +++---------
.../transaction-factory/src/complex_mode.rs | 157 ---------------
.../bin/node/transaction-factory/src/lib.rs | 182 ++++++++----------
.../bin/node/transaction-factory/src/modes.rs | 40 ----
.../transaction-factory/src/simple_modes.rs | 112 -----------
7 files changed, 113 insertions(+), 540 deletions(-)
delete mode 100644 substrate/bin/node/transaction-factory/src/complex_mode.rs
delete mode 100644 substrate/bin/node/transaction-factory/src/modes.rs
delete mode 100644 substrate/bin/node/transaction-factory/src/simple_modes.rs
diff --git a/substrate/bin/node/cli/src/cli.rs b/substrate/bin/node/cli/src/cli.rs
index dd3ee4a5966..7844c2c0a52 100644
--- a/substrate/bin/node/cli/src/cli.rs
+++ b/substrate/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)]
diff --git a/substrate/bin/node/cli/src/command.rs b/substrate/bin/node/cli/src/command.rs
index 3bfed148f58..61d10517966 100644
--- a/substrate/bin/node/cli/src/command.rs
+++ b/substrate/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;
diff --git a/substrate/bin/node/cli/src/factory_impl.rs b/substrate/bin/node/cli/src/factory_impl.rs
index a1c5a5f4e05..1d1eabe29cb 100644
--- a/substrate/bin/node/cli/src/factory_impl.rs
+++ b/substrate/bin/node/cli/src/factory_impl.rs
@@ -33,7 +33,6 @@ 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;
@@ -41,14 +40,10 @@ 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;
@@ -78,63 +73,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,
@@ -143,10 +110,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()),
@@ -157,12 +126,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, ×tamp)
.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
}
@@ -180,49 +149,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] {
diff --git a/substrate/bin/node/transaction-factory/src/complex_mode.rs b/substrate/bin/node/transaction-factory/src/complex_mode.rs
deleted file mode 100644
index 6d7e60c8d3c..00000000000
--- a/substrate/bin/node/transaction-factory/src/complex_mode.rs
+++ /dev/null
@@ -1,157 +0,0 @@
-// Copyright 2019-2020 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 sc_client::Client;
-use sp_block_builder::BlockBuilder;
-use sp_api::{ConstructRuntimeApi, ProvideRuntimeApi};
-use sp_runtime::generic::BlockId;
-use sp_runtime::traits::{Block as BlockT, 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,
- Exec: sc_client::CallExecutor<Block, Backend = Backend> + Send + Sync + Clone,
- Backend: sc_client_api::backend::Backend<Block> + Send,
- Client<Backend, Exec, Block, RtApi>: ProvideRuntimeApi<Block>,
- <Client<Backend, Exec, Block, RtApi> as ProvideRuntimeApi<Block>>::Api:
- BlockBuilder<Block, Error = sp_blockchain::Error> +
- sp_api::ApiExt<Block, StateBackend = Backend::State>,
- 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))
- },
- }
-}
diff --git a/substrate/bin/node/transaction-factory/src/lib.rs b/substrate/bin/node/transaction-factory/src/lib.rs
index a0c6a4f663c..12c24e4f2f6 100644
--- a/substrate/bin/node/transaction-factory/src/lib.rs
+++ b/substrate/bin/node/transaction-factory/src/lib.rs
@@ -39,11 +39,6 @@ use sp_runtime::generic::BlockId;
use sp_runtime::traits::{
Block as BlockT, Header as HeaderT, SimpleArithmetic, One, Zero,
};
-pub use crate::modes::Mode;
-
-pub mod modes;
-mod complex_mode;
-mod simple_modes;
pub trait RuntimeAdapter {
type AccountId: Display;
@@ -54,22 +49,16 @@ pub trait RuntimeAdapter {
type Phase: Copy;
type Secret;
- fn new(mode: Mode, rounds: u64, start_number: u64) -> Self;
+ fn new(blocks: u32, transactions: u32) -> 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 blocks(&self) -> u32;
+ fn transactions(&self) -> u32;
- 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 block_number(&self) -> u32;
+ fn set_block_number(&mut self, value: u32);
fn transfer_extrinsic(
- &self,
+ &mut self,
sender: &Self::AccountId,
key: &Self::Secret,
destination: &Self::AccountId,
@@ -84,14 +73,12 @@ pub trait RuntimeAdapter {
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;
+
+ fn gen_random_account_id(seed: u32) -> Self::AccountId;
+ fn gen_random_account_secret(seed: u32) -> Self::Secret;
}
-/// Manufactures transactions. The exact amount depends on
-/// `mode`, `num` and `rounds`.
+/// Manufactures transactions. The exact amount depends on `num` and `rounds`.
pub fn factory<RA, Backend, Exec, Block, RtApi, Sc>(
mut factory_state: RA,
client: &Arc<Client<Backend, Exec, Block, RtApi>>,
@@ -110,11 +97,6 @@ where
RA: RuntimeAdapter<Block = Block>,
Block::Hash: From<sp_core::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(sc_cli::error::Error::Input(msg));
- }
-
let best_header: Result<<Block as BlockT>::Header, sc_cli::error::Error> =
select_chain.best_chain().map_err(|e| format!("{:?}", e).into());
let mut best_hash = best_header?.hash();
@@ -123,89 +105,75 @@ where
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,
- ),
- } {
+ while factory_state.block_number() < factory_state.blocks() {
+ let from = (RA::master_account_id(), RA::master_account_secret());
+ let amount = RA::minimum_balance();
+
+ let inherents = RA::inherent_extrinsics(&factory_state);
+ let inherents = client.runtime_api().inherent_extrinsics(&best_block_id, inherents)
+ .expect("Failed to create inherent extrinsics");
+
+ let tx_per_block = factory_state.transactions();
+
+ let mut block = client.new_block(Default::default()).expect("Failed to create new block");
+
+ for tx_num in 0..tx_per_block {
+ let seed = tx_num * (factory_state.block_number() + 1);
+ let to = RA::gen_random_account_id(seed);
+
+ let transfer = factory_state.transfer_extrinsic(
+ &from.0,
+ &from.1,
+ &to,
+ &amount,
+ version,
+ &genesis_hash,
+ &best_hash,
+ );
+
+ info!("Pushing transfer {}/{} to {} into block.", tx_num + 1, tx_per_block, to);
+
+ block.push(
+ Decode::decode(&mut &transfer.encode()[..])
+ .expect("Failed to decode transfer extrinsic")
+ ).expect("Failed to push transfer extrinsic into block");
+ }
+
+ for inherent in inherents {
+ block.push(inherent).expect("Failed ...");
+ }
+
+ let block = block.build().expect("Failed to bake block").block;
+
+ factory_state.set_block_number(factory_state.block_number() + 1);
+
+ info!(
+ "Created block {} with hash {}.",
+ factory_state.block_number(),
+ best_hash,
+ );
+
best_hash = block.header().hash();
best_block_id = BlockId::<Block>::hash(best_hash);
- import_block(client.clone(), block);
- info!("Imported block at {}", factory_state.block_no());
+ let import = BlockImportParams {
+ origin: BlockOrigin::File,
+ header: block.header().clone(),
+ post_digests: Vec::new(),
+ body: Some(block.extrinsics().to_vec()),
+ storage_changes: None,
+ finalized: false,
+ justification: None,
+ auxiliary: Vec::new(),
+ intermediates: Default::default(),
+ fork_choice: Some(ForkChoiceStrategy::LongestChain),
+ allow_missing_state: false,
+ import_existing: false,
+ };
+ client.clone().import_block(import, HashMap::new()).expect("Failed to import block");
+
+ info!("Imported block at {}", factory_state.block_number());
}
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,
- Exec: sc_client::CallExecutor<Block, Backend = Backend> + Send + Sync + Clone,
- Backend: sc_client_api::backend::Backend<Block> + Send,
- Client<Backend, Exec, Block, RtApi>: ProvideRuntimeApi<Block>,
- RtApi: ConstructRuntimeApi<Block, Client<Backend, Exec, Block, RtApi>> + Send + Sync,
- <Client<Backend, Exec, Block, RtApi> as ProvideRuntimeApi<Block>>::Api:
- BlockBuilder<Block, Error = sp_blockchain::Error> +
- ApiExt<Block, StateBackend = Backend::State>,
- 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.build().expect("Failed to bake block").block
-}
-
-fn import_block<Backend, Exec, Block, RtApi>(
- mut client: Arc<Client<Backend, Exec, Block, RtApi>>,
- block: Block
-) -> () where
- Block: BlockT,
- Exec: sc_client::CallExecutor<Block> + Send + Sync + Clone,
- Backend: sc_client_api::backend::Backend<Block> + Send,
- Client<Backend, Exec, Block, RtApi>: ProvideRuntimeApi<Block>,
- <Client<Backend, Exec, Block, RtApi> as ProvideRuntimeApi<Block>>::Api:
- sp_api::Core<Block, Error = sp_blockchain::Error> +
- ApiExt<Block, StateBackend = Backend::State>,
-{
- let import = BlockImportParams {
- origin: BlockOrigin::File,
- header: block.header().clone(),
- post_digests: Vec::new(),
- body: Some(block.extrinsics().to_vec()),
- storage_changes: None,
- finalized: false,
- justification: None,
- auxiliary: Vec::new(),
- intermediates: Default::default(),
- fork_choice: Some(ForkChoiceStrategy::LongestChain),
- allow_missing_state: false,
- import_existing: false,
- };
- client.import_block(import, HashMap::new()).expect("Failed to import block");
-}
diff --git a/substrate/bin/node/transaction-factory/src/modes.rs b/substrate/bin/node/transaction-factory/src/modes.rs
deleted file mode 100644
index 5deab7635e1..00000000000
--- a/substrate/bin/node/transaction-factory/src/modes.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright 2019-2020 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)),
- }
- }
-}
diff --git a/substrate/bin/node/transaction-factory/src/simple_modes.rs b/substrate/bin/node/transaction-factory/src/simple_modes.rs
deleted file mode 100644
index fba328731a9..00000000000
--- a/substrate/bin/node/transaction-factory/src/simple_modes.rs
+++ /dev/null
@@ -1,112 +0,0 @@
-// Copyright 2019-2020 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 sc_client::Client;
-use sp_block_builder::BlockBuilder;
-use sp_api::{ConstructRuntimeApi, ProvideRuntimeApi};
-use sp_runtime::traits::{Block as BlockT, 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,
- Exec: sc_client::CallExecutor<Block, Backend = Backend> + Send + Sync + Clone,
- Backend: sc_client_api::backend::Backend<Block> + Send,
- Client<Backend, Exec, Block, RtApi>: ProvideRuntimeApi<Block>,
- <Client<Backend, Exec, Block, RtApi> as ProvideRuntimeApi<Block>>::Api:
- BlockBuilder<Block, Error = sp_blockchain::Error> +
- sp_api::ApiExt<Block, StateBackend = Backend::State>,
- 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)
-}
--
GitLab