pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-04-26 14:37:57 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove tx factory (#5890)

Browse Source 
* Remove tx factory files.

* Remove unused imports.

* Revert cargo lock.
This commit is contained in:
Marcio Diaz
2020-05-05 13:54:51 +02:00
committed by GitHub
parent 16af2642ff
commit 4b44c73a4d
10 changed files with 3 additions and 539 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/bin/node/cli/src/cli.rs
+1 -29
View File
@@ -14,7 +14,7 @@
// You should have received a copy of the GNU General Public License
// along with Substrate. If not, see <http://www.gnu.org/licenses/>.
use sc_cli::{ImportParams, RunCmd, SharedParams};
use sc_cli::RunCmd;
use structopt::StructOpt;
/// An overarching CLI command definition.
@@ -34,13 +34,6 @@ pub enum Subcommand {
/// A set of base subcommands handled by `sc_cli`.
#[structopt(flatten)]
Base(sc_cli::Subcommand),
/// 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),
/// The custom inspect subcommmand for decoding blocks and extrinsics.
#[structopt(
@@ -53,24 +46,3 @@ pub enum Subcommand {
#[structopt(name = "benchmark", about = "Benchmark runtime pallets.")]
Benchmark(frame_benchmarking_cli::BenchmarkCmd),
}
/// 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 {
/// Number of blocks to generate.
#[structopt(long = "blocks", default_value = "1")]
pub blocks: u32,
/// Number of transactions to push per block.
#[structopt(long = "transactions", default_value = "8")]
pub transactions: u32,
#[allow(missing_docs)]
#[structopt(flatten)]
pub shared_params: SharedParams,
#[allow(missing_docs)]
#[structopt(flatten)]
pub import_params: ImportParams,
}
substrate/bin/node/cli/src/command.rs
+2 -50
View File
@@ -14,12 +14,10 @@
// You should have received a copy of the GNU General Public License
// along with Substrate. If not, see <http://www.gnu.org/licenses/>.
use crate::{chain_spec, factory_impl::FactoryState, service, Cli, FactoryCmd, Subcommand};
use crate::{chain_spec, service, Cli, Subcommand};
use node_executor::Executor;
use node_runtime::{Block, RuntimeApi};
use node_transaction_factory::RuntimeAdapter;
use sc_cli::{CliConfiguration, ImportParams, Result, SharedParams, SubstrateCli};
use sc_service::Configuration;
use sc_cli::{Result, SubstrateCli};
impl SubstrateCli for Cli {
fn impl_name() -> &'static str {
@@ -94,11 +92,6 @@ pub fn run() -> Result<()> {
Ok(())
}
}
Some(Subcommand::Factory(cmd)) => {
let runner = cli.create_runner(cmd)?;
runner.sync_run(|config| cmd.run(config))
}
Some(Subcommand::Base(subcommand)) => {
let runner = cli.create_runner(subcommand)?;
@@ -106,44 +99,3 @@ pub fn run() -> Result<()> {
}
}
}
impl CliConfiguration for FactoryCmd {
fn shared_params(&self) -> &SharedParams {
&self.shared_params
}
fn import_params(&self) -> Option<&ImportParams> {
Some(&self.import_params)
}
}
impl FactoryCmd {
fn run(&self, config: Configuration) -> Result<()> {
match config.chain_spec.id() {
"dev" | "local" => {}
_ => return Err("Factory is only supported for development and local testnet.".into()),
}
// Setup tracing.
if let Some(tracing_targets) = self.import_params.tracing_targets.as_ref() {
let subscriber = sc_tracing::ProfilingSubscriber::new(
self.import_params.tracing_receiver.into(),
tracing_targets,
);
if let Err(e) = tracing::subscriber::set_global_default(subscriber) {
return Err(format!("Unable to set global default subscriber {}", e).into());
}
}
let factory_state = FactoryState::new(self.blocks, self.transactions);
let service_builder = new_full_start!(config).0;
node_transaction_factory::factory(
factory_state,
service_builder.client(),
service_builder
.select_chain()
.expect("The select_chain is always initialized by new_full_start!; qed"),
)
}
}
substrate/bin/node/cli/src/factory_impl.rs
-203
View File
@@ -1,203 +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/>.
//! 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 codec::{Encode, Decode};
use sp_keyring::sr25519::Keyring;
use node_runtime::{
Call, CheckedExtrinsic, UncheckedExtrinsic, SignedExtra, BalancesCall, ExistentialDeposit,
MinimumPeriod
};
use node_primitives::Signature;
use sp_core::{sr25519, crypto::Pair};
use sp_runtime::{
generic::Era, traits::{Block as BlockT, Header as HeaderT, SignedExtension, Verify, IdentifyAccount}
};
use node_transaction_factory::RuntimeAdapter;
use sp_inherents::InherentData;
use sp_timestamp;
use sp_finality_tracker;
type AccountPublic = <Signature as Verify>::Signer;
pub struct FactoryState<N> {
blocks: u32,
transactions: u32,
block_number: N,
index: u32,
}
type Number = <<node_primitives::Block as BlockT>::Header as HeaderT>::Number;
impl<Number> FactoryState<Number> {
fn build_extra(index: node_primitives::Index, phase: u64) -> node_runtime::SignedExtra {
(
frame_system::CheckVersion::new(),
frame_system::CheckGenesis::new(),
frame_system::CheckEra::from(Era::mortal(256, phase)),
frame_system::CheckNonce::from(index),
frame_system::CheckWeight::new(),
pallet_transaction_payment::ChargeTransactionPayment::from(0),
)
}
}
impl RuntimeAdapter for FactoryState<Number> {
type AccountId = node_primitives::AccountId;
type Balance = node_primitives::Balance;
type Block = node_primitives::Block;
type Phase = sp_runtime::generic::Phase;
type Secret = sr25519::Pair;
type Index = node_primitives::Index;
type Number = Number;
fn new(
blocks: u32,
transactions: u32,
) -> FactoryState<Self::Number> {
FactoryState {
blocks,
transactions,
block_number: 0,
index: 0,
}
}
fn block_number(&self) -> u32 {
self.block_number
}
fn blocks(&self) -> u32 {
self.blocks
}
fn transactions(&self) -> u32 {
self.transactions
}
fn set_block_number(&mut self, value: u32) {
self.block_number = value;
}
fn transfer_extrinsic(
&mut self,
sender: &Self::AccountId,
key: &Self::Secret,
destination: &Self::AccountId,
amount: &Self::Balance,
version: u32,
genesis_hash: &<Self::Block as BlockT>::Hash,
prior_block_hash: &<Self::Block as BlockT>::Hash,
) -> <Self::Block as BlockT>::Extrinsic {
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(), extra)),
function: Call::Balances(
BalancesCall::transfer(
pallet_indices::address::Address::Id(destination.clone().into()),
(*amount).into()
)
)
}, key, (version, genesis_hash.clone(), prior_block_hash.clone(), (), (), ()))
}
fn inherent_extrinsics(&self) -> InherentData {
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_number)
.expect("Failed putting finalized number inherent");
inherent
}
fn minimum_balance() -> Self::Balance {
ExistentialDeposit::get()
}
fn master_account_id() -> Self::AccountId {
Keyring::Alice.to_account_id()
}
fn master_account_secret() -> Self::Secret {
Keyring::Alice.pair()
}
/// Generates a random `AccountId` from `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: u32) -> Self::Secret {
let pair: sr25519::Pair = sr25519::Pair::from_seed(&gen_seed_bytes(seed));
pair
}
}
fn gen_seed_bytes(seed: u32) -> [u8; 32] {
let mut rng: StdRng = SeedableRng::seed_from_u64(seed as u64);
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<RA: RuntimeAdapter>(
xt: CheckedExtrinsic,
key: &sr25519::Pair,
additional_signed: <SignedExtra as SignedExtension>::AdditionalSigned,
) -> <RA::Block as BlockT>::Extrinsic {
let s = match xt.signed {
Some((signed, extra)) => {
let payload = (xt.function, extra.clone(), additional_signed);
let signature = payload.using_encoded(|b| {
if b.len() > 256 {
key.sign(&sp_io::hashing::blake2_256(b))
} else {
key.sign(b)
}
}).into();
UncheckedExtrinsic {
signature: Some((pallet_indices::address::Address::Id(signed), signature, extra)),
function: payload.0,
}
}
None => UncheckedExtrinsic {
signature: None,
function: xt.function,
},
};
let e = Encode::encode(&s);
Decode::decode(&mut &e[..]).expect("Failed to decode signed unchecked extrinsic")
}
substrate/bin/node/cli/src/lib.rs
-2
View File
@@ -37,8 +37,6 @@ mod browser;
#[cfg(feature = "cli")]
mod cli;
#[cfg(feature = "cli")]
mod factory_impl;
#[cfg(feature = "cli")]
mod command;
#[cfg(feature = "browser")]