net_test.rs

use crate::*;

use anyhow::{anyhow, Result};
use sp_core::{crypto::AccountId32, sr25519::Pair, DeriveJunction, Pair as _};
use subxt::{
	ext::sp_runtime::MultiAddress,
	tx::{BaseExtrinsicParamsBuilder, PairSigner},
};

pub async fn repart(
	pair: Pair,
	client: &Client,
	target: u32,
	actual_repart: Option<u32>,
) -> Result<()> {
	let mut pairs = Vec::new();
	for i in actual_repart.unwrap_or_default()..target {
		let pair_i = pair
			.derive(std::iter::once(DeriveJunction::hard::<u32>(i)), None)
			.map_err(|_| anyhow!("Fail to derive //{}", i))?
			.0;
		pairs.push((i, pair_i));
	}

	for (i, pair_i) in &pairs {
		/*let _ = api
			.tx()
			.balances()
			.transfer(MultiAddress::Id(pair_i.public().into()), 501)?
			.sign_and_submit_then_watch(&signer, BaseExtrinsicParamsBuilder::new())
			.await?
			.wait_for_in_block()
			.await?;
		signer.increment_nonce();*/

		if let Some(pair_i_account) = client
			.storage()
			.fetch(
				&runtime::storage().system().account(&pair_i.public().into()),
				None,
			)
			.await?
		{
			log::info!("account //{} balance: {}", i, pair_i_account.data.free);
		}
	}

	Ok(())
}

pub async fn spam_roll(pair: Pair, client: &Client, actual_repart: usize) -> Result<()> {
	let mut nonce = 0;
	let mut pairs = Vec::<(PairSigner<Runtime, Pair>, AccountId32)>::with_capacity(actual_repart);
	for i in 0..actual_repart {
		let pair_i = pair
			.derive(std::iter::once(DeriveJunction::hard::<u32>(i as u32)), None)
			.map_err(|_| anyhow!("Fail to derive //{}", i))?
			.0;
		let account_id_i = pair_i.public().into();
		pairs.push((PairSigner::new(pair_i), account_id_i));
	}

	loop {
		let mut watchers = Vec::with_capacity(actual_repart);
		for i in 0..(actual_repart - 1) {
			let dest: AccountId32 = pairs[i + 1].1.clone();
			let watcher = client
				.tx()
				.create_signed_with_nonce(
					&runtime::tx().balances().transfer(MultiAddress::Id(dest), 1),
					&pairs[i].0,
					nonce,
					BaseExtrinsicParamsBuilder::new(),
				)?
				.submit_and_watch()
				.await?;
			nonce += 1;
			log::info!("send 1 cent from //{} to //{}", i, i + 1);
			watchers.push(watcher);
		}
		let dest: AccountId32 = pairs[0].1.clone();
		let watcher = client
			.tx()
			.sign_and_submit_then_watch(
				&runtime::tx().balances().transfer(MultiAddress::Id(dest), 1),
				&pairs[actual_repart - 1].0,
				BaseExtrinsicParamsBuilder::new(),
			)
			.await?;
		nonce += 1;
		log::info!("send 1 cent from //{} to //0", actual_repart - 1);
		watchers.push(watcher);

		// Wait all transactions
		for watcher in watchers {
			watcher.wait_for_in_block().await?;
		}
	}
}