pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-06-12 04:11:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

Refactor tx factory 1 (#4870)

Browse Source 
* Remove modes.

* Refactor.
This commit is contained in:
Marcio Diaz
2020-02-11 13:59:52 +01:00
committed by GitHub
parent b0a749548d
commit a90b4fdb8c
7 changed files with 113 additions and 540 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/bin/node/cli/src/cli.rs
+6 -27
View File
@@ -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)]
substrate/bin/node/cli/src/command.rs
+2 -3
View File
@@ -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;
substrate/bin/node/cli/src/factory_impl.rs
+30 -94
View File
@@ -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_number(&self) -> u32 {
self.block_number
}
fn block_in_round(&self) -> Self::Number {
self.block_in_round
fn blocks(&self) -> u32 {
self.blocks
}
fn rounds(&self) -> Self::Number {
self.rounds
fn transactions(&self) -> u32 {
self.transactions
}
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 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, &timestamp)
.expect("Failed putting timestamp inherent");
inherent.put_data(sp_finality_tracker::INHERENT_IDENTIFIER, &self.block_no)
inherent.put_data(sp_finality_tracker::INHERENT_IDENTIFIER, &self.block_number)
.expect("Failed putting finalized number inherent");
inherent
}
@@ -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] {
substrate/bin/node/transaction-factory/src/complex_mode.rs
-157
View File
@@ -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))
},
}
}
substrate/bin/node/transaction-factory/src/lib.rs
+75 -107
View File
@@ -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");
}
substrate/bin/node/transaction-factory/src/modes.rs
-40
View File
@@ -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)),
}
}
}
substrate/bin/node/transaction-factory/src/simple_modes.rs
-112
View File
@@ -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)
}