Refactor tx factory 1 (#4870)

* Remove modes. * Refactor.
2026-07-13 15:05:50 +00:00 · 2020-02-11 13:59:52 +01:00
parent b0a749548d
commit a90b4fdb8c
7 changed files with 113 additions and 540 deletions
@@ -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");
-}