mirror of
https://github.com/pezkuwichain/pezkuwi-subxt.git
synced 2026-05-08 04:18:01 +00:00
Tomasz Drwięga
8778ca7dc8
* Rename: Phase 1. * Unify codec. * Fixing: Phase 2 * Fixing: Phase 3. * Fixing: Phase 4. * Fixing: Phase 5. * Fixing: Phase 6. * Fixing: Phase 7. * Fixing: Phase 8. Tests * Fixing: Phase 9. Tests!!! * Fixing: Phase 10. Moar tests! * Finally done! * More fixes. * Rename primitives:: to sp_core:: * Apply renames in finality-grandpa. * Fix benches. * Fix benches 2. * Revert node-template. * Fix frame-system in our modules.
113 lines
3.3 KiB
Rust
113 lines
3.3 KiB
Rust
// 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 sc_client::Client;
|
|
use sp_block_builder::BlockBuilder;
|
|
use sp_api::ConstructRuntimeApi;
|
|
use sp_core::{Blake2Hasher, Hasher};
|
|
use sp_runtime::traits::{Block as BlockT, ProvideRuntimeApi, One};
|
|
use sp_runtime::generic::BlockId;
|
|
|
|
use crate::{Mode, RuntimeAdapter, create_block};
|
|
|
|
pub fn next<RA, Backend, Exec, Block, RtApi>(
|
|
factory_state: &mut RA,
|
|
client: &Arc<Client<Backend, Exec, Block, RtApi>>,
|
|
version: u32,
|
|
genesis_hash: <RA::Block as BlockT>::Hash,
|
|
prior_block_hash: <RA::Block as BlockT>::Hash,
|
|
prior_block_id: BlockId<Block>,
|
|
) -> Option<Block>
|
|
where
|
|
Block: BlockT<Hash = <Blake2Hasher as Hasher>::Out>,
|
|
Exec: sc_client::CallExecutor<Block, Blake2Hasher> + Send + Sync + Clone,
|
|
Backend: sc_client_api::backend::Backend<Block, Blake2Hasher> + Send,
|
|
Client<Backend, Exec, Block, RtApi>: ProvideRuntimeApi,
|
|
<Client<Backend, Exec, Block, RtApi> as ProvideRuntimeApi>::Api:
|
|
BlockBuilder<Block, Error = sp_blockchain::Error>,
|
|
RtApi: ConstructRuntimeApi<Block, Client<Backend, Exec, Block, RtApi>> + Send + Sync,
|
|
RA: RuntimeAdapter,
|
|
{
|
|
if factory_state.block_no() >= factory_state.num() {
|
|
return None;
|
|
}
|
|
|
|
let from = (RA::master_account_id(), RA::master_account_secret());
|
|
|
|
let seed = match factory_state.mode() {
|
|
// choose the same receiver for all transactions
|
|
Mode::MasterTo1 => factory_state.start_number(),
|
|
|
|
// different receiver for each transaction
|
|
Mode::MasterToN => factory_state.start_number() + factory_state.block_no(),
|
|
_ => unreachable!("Mode not covered!"),
|
|
};
|
|
let to = RA::gen_random_account_id(&seed);
|
|
|
|
let amount = RA::minimum_balance();
|
|
|
|
let transfer = factory_state.transfer_extrinsic(
|
|
&from.0,
|
|
&from.1,
|
|
&to,
|
|
&amount,
|
|
version,
|
|
&genesis_hash,
|
|
&prior_block_hash,
|
|
);
|
|
|
|
let inherents = RA::inherent_extrinsics(&factory_state);
|
|
let inherents = client.runtime_api().inherent_extrinsics(&prior_block_id, inherents)
|
|
.expect("Failed to create inherent extrinsics");
|
|
|
|
let block = create_block::<RA, _, _, _, _>(&client, transfer, inherents);
|
|
|
|
factory_state.set_block_no(factory_state.block_no() + RA::Number::one());
|
|
|
|
info!(
|
|
"Created block {} with hash {}. Transferring {} from {} to {}.",
|
|
factory_state.block_no(),
|
|
prior_block_hash,
|
|
amount,
|
|
from.0,
|
|
to
|
|
);
|
|
|
|
Some(block)
|
|
}
|