add smith and membership commands

.vscode/settings.json

+{
+    "rust-analyzer.server.extraEnv": null,
+    "windicss.includeLanguages": {}
+}
\ No newline at end of file

doc/example.md

@@ -15,7 +15,8 @@ gcli config where
 gcli --network gdev config save
 # save config to use Alice predefined secret
 gcli -S predefined -s Alice config save
-# these can be combined
+# the arguments above can be combined
+# command below sets local network and predefined secret
 gcli --network local -S predefined -s test1 config save
 ```
 
@@ -23,6 +24,8 @@ In the following, we assume this last command was run.
 
 ## Commands
 
+Here is a list of useful commands
+
 ```sh
 # get duniter current block
 gcli blockchain current-block
@@ -38,6 +41,15 @@ gcli ud claim
 gcli account transfer 5000 5E4i8vcNjnrDp21Sbnp32WHm2gz8YP3GGFwmdpfg5bHd8Whb
 ```
 
+For testing purpose it can be useful to submit extrinsic without waiting for result and create block manually. 
+
+```sh
+# only submit extrinsic to network and do not listen to result
+gcli --no-wait account transfer 1234 5FeggKqw2AbnGZF9Y9WPM2QTgzENS3Hit94Ewgmzdg5a3LNa
+# create block manually (with manual sealing)
+gcli blockchain create-block
+```
+
 ## Indexer commands
 
 You can check first that indexer is on the same network as Duniter node:

rust-toolchain.toml

+[toolchain]
+channel = "nightly"

src/commands.rs

 pub mod account;
 pub mod blockchain;
+pub mod certification;
 pub mod collective;
 pub mod expire;
 pub mod identity;

src/commands/account.rs

@@ -32,7 +32,7 @@ pub async fn handle_command(data: Data, command: Subcommand) -> anyhow::Result<(
 	match command {
 		Subcommand::Balance => {
 			data = data.fetch_system_properties().await?;
-			commands::account::get_balance(data).await?
+			get_balance(data).await?
 		}
 		Subcommand::Transfer {
 			amount,

src/commands/blockchain.rs

@@ -18,6 +18,9 @@ pub enum Subcommand {
 	/// Check current block
 	#[default]
 	CurrentBlock,
+	/// Create one block manually (manual sealing)
+	#[clap(hide = true)]
+	CreateBlock,
 }
 
 /// handle blockchain commands
@@ -46,6 +49,12 @@ pub async fn handle_command(data: Data, command: Subcommand) -> anyhow::Result<(
 					.unwrap()
 			);
 		}
+		Subcommand::CreateBlock => {
+			data.client()
+				.rpc()
+				.request("engine_createBlock", subxt::rpc::rpc_params![true, true]) // create empty block and finalize
+				.await?; // FIXME this gives a serialization error
+		}
 	}
 	Ok(())
 }

src/commands/certification.rs

+use crate::*;
+
+/// submit a certification and track progress
+pub async fn certify(data: &Data, receiver: u32) -> Result<(), anyhow::Error> {
+	let progress = data
+		.client()
+		.tx()
+		.sign_and_submit_then_watch(
+			&runtime::tx().cert().add_cert(data.idty_index(), receiver),
+			&PairSigner::new(data.keypair()),
+			BaseExtrinsicParamsBuilder::new(),
+		)
+		.await?;
+
+	if data.args.no_wait {
+		return Ok(());
+	}
+	let events = track_progress(progress).await?;
+
+	// look for the expected event
+	let new_cert_event = events.find_first::<runtime::cert::events::NewCert>()?;
+	let renew_cert_event = events.find_first::<runtime::cert::events::RenewedCert>()?;
+
+	if let Some(event) = new_cert_event {
+		println!("{event:?}");
+	}
+	if let Some(event) = renew_cert_event {
+		println!("{event:?}");
+	}
+
+	Ok(())
+}

src/commands/collective.rs

@@ -147,6 +147,9 @@ pub async fn technical_committee_vote(
 		)
 		.await?;
 
+	if data.args.no_wait {
+		return Ok(());
+	}
 	let events = track_progress(progress).await?;
 
 	if let Some(e) = events.find_first::<runtime::technical_committee::events::Voted>()? {

src/commands/identity.rs

 use crate::*;
 
-use crate::commands::revocation::generate_revoc_doc;
-use crate::runtime::runtime_types::common_runtime::entities::IdtyData;
-use crate::runtime::runtime_types::pallet_identity::types::*;
-use crate::runtime::runtime_types::sp_core::sr25519::Signature;
-use crate::runtime::runtime_types::sp_runtime::MultiSignature;
+use crate::{
+	commands::revocation::generate_revoc_doc,
+	runtime::runtime_types::{
+		common_runtime::entities::IdtyData, pallet_identity::types::*, sp_core::sr25519::Signature,
+		sp_runtime::MultiSignature,
+	},
+};
 use std::str::FromStr;
 
 /// define identity subcommands
@@ -30,10 +32,14 @@ pub enum Subcommand {
 	///
 	/// To be called by the certified not-yet-member account, to become member.
 	Confirm { name: String },
+	/// Certify an identity
+	Certify { target: u32 },
 	/// Revoke an identity immediately
 	Revoke,
 	/// Generate a revocation document for the provided account
 	GenRevocDoc,
+	/// Display member count
+	MemberCount,
 }
 
 /// handle identity commands
@@ -47,28 +53,41 @@ pub async fn handle_command(data: Data, command: Subcommand) -> anyhow::Result<(
 			ref username,
 		} => {
 			data = data.build_indexer().await?;
-			commands::identity::get_identity(
-				&data,
-				account_id.clone(),
-				identity_id,
-				username.clone(),
-			)
-			.await?
+			get_identity(&data, account_id.clone(), identity_id, username.clone()).await?
 		}
 		Subcommand::Create { target } => {
-			commands::identity::create_identity(data.keypair(), data.client(), target).await?;
+			create_identity(&data, target).await?;
 		}
 		Subcommand::Confirm { name } => {
-			commands::identity::confirm_identity(data.keypair(), data.client(), name).await?;
+			confirm_identity(&data, name).await?;
+		}
+		Subcommand::Certify { target } => {
+			data = data.fetch_idty_index().await?;
+			// TODO fetch target username / key / index
+			// and ask user to confirm certification
+			commands::certification::certify(&data, target).await?;
 		}
 		Subcommand::Revoke => {
 			data = data.fetch_idty_index().await?;
-			commands::identity::revoke_identity(data).await?;
+			revoke_identity(data).await?;
 		}
 		Subcommand::GenRevocDoc => {
 			data = data.fetch_idty_index().await?;
 			commands::revocation::print_revoc_sig(&data)
 		}
+		Subcommand::MemberCount => {
+			println!(
+				"member count: {}",
+				data.client()
+					.storage()
+					.fetch(
+						&runtime::storage().membership().counter_for_membership(),
+						None,
+					)
+					.await?
+					.unwrap()
+			)
+		}
 	};
 
 	Ok(())
@@ -166,20 +185,20 @@ pub async fn get_identity_by_index(
 }
 
 /// created identity
-pub async fn create_identity(
-	pair: Pair,
-	client: &Client,
-	target: AccountId,
-) -> Result<(), subxt::Error> {
-	let progress = client
+pub async fn create_identity(data: &Data, target: AccountId) -> Result<(), subxt::Error> {
+	let progress = data
+		.client()
 		.tx()
 		.sign_and_submit_then_watch(
 			&runtime::tx().identity().create_identity(target),
-			&PairSigner::new(pair),
+			&PairSigner::new(data.keypair()),
 			BaseExtrinsicParamsBuilder::new(),
 		)
 		.await?;
 
+	if data.args.no_wait {
+		return Ok(());
+	}
 	let events = track_progress(progress).await?;
 	if let Some(e) = events.find_first::<runtime::identity::events::IdtyCreated>()? {
 		println!("{e:?}");
@@ -188,20 +207,20 @@ pub async fn create_identity(
 }
 
 /// confirm identity
-pub async fn confirm_identity(
-	pair: Pair,
-	client: &Client,
-	name: String,
-) -> Result<(), subxt::Error> {
-	let progress = client
+pub async fn confirm_identity(data: &Data, name: String) -> Result<(), subxt::Error> {
+	let progress = data
+		.client()
 		.tx()
 		.sign_and_submit_then_watch(
 			&runtime::tx().identity().confirm_identity(name),
-			&PairSigner::new(pair),
+			&PairSigner::new(data.keypair()),
 			BaseExtrinsicParamsBuilder::new(),
 		)
 		.await?;
 
+	if data.args.no_wait {
+		return Ok(());
+	}
 	let events = track_progress(progress).await?;
 	if let Some(e) = events.find_first::<runtime::identity::events::IdtyConfirmed>()? {
 		println!("{e:?}");
@@ -230,6 +249,9 @@ pub async fn revoke_identity(data: Data) -> Result<(), subxt::Error> {
 		)
 		.await?;
 
+	if data.args.no_wait {
+		return Ok(());
+	}
 	let events = track_progress(progress).await?;
 	if let Some(e) = events.find_first::<runtime::identity::events::IdtyRemoved>()? {
 		println!("{e:?}");

src/commands/oneshot.rs

@@ -102,6 +102,9 @@ pub async fn create_oneshot_account(
 		)
 		.await?;
 
+	if data.args.no_wait {
+		return Ok(());
+	}
 	let events = track_progress(progress).await?;
 	if let Some(e) =
 		events.find_first::<runtime::oneshot_account::events::OneshotAccountCreated>()?
@@ -145,6 +148,9 @@ pub async fn consume_oneshot_account(
 		)
 		.await?;
 
+	if data.args.no_wait {
+		return Ok(());
+	}
 	let events = track_progress(progress).await?;
 	if let Some(e) =
 		events.find_first::<runtime::oneshot_account::events::OneshotAccountConsumed>()?
@@ -157,7 +163,6 @@ pub async fn consume_oneshot_account(
 /// consume oneshot account with remaining
 pub async fn consume_oneshot_account_with_remaining(
 	data: &Data,
-
 	balance: u64,
 	dest: AccountId,
 	dest_oneshot: bool,
@@ -203,6 +208,9 @@ pub async fn consume_oneshot_account_with_remaining(
 		)
 		.await?;
 
+	if data.args.no_wait {
+		return Ok(());
+	}
 	let events = track_progress(progress).await?;
 	if let Some(e) =
 		events.find_first::<runtime::oneshot_account::events::OneshotAccountConsumed>()?

src/commands/smith.rs

@@ -14,6 +14,10 @@ pub enum Subcommand {
 	Request { endpoint: String },
 	/// Emit a smith certification
 	Cert { to: u32 },
+	/// Claim smith membership
+	Claim,
+	/// Renew smith membership
+	Renew,
 	/// go online
 	GoOnline,
 	/// go offline
@@ -34,6 +38,8 @@ pub enum Subcommand {
 	},
 	/// List online authorities
 	ShowOnline,
+	/// count of smith member
+	MemberCount,
 }
 
 /// handle smith commands
@@ -41,7 +47,13 @@ pub async fn handle_command(data: Data, command: Subcommand) -> anyhow::Result<(
 	let mut data = data.build_client().await?;
 	match command {
 		Subcommand::Request { endpoint } => {
-			dbg!(request_smith_membership(&data, endpoint).await)?;
+			request_smith_membership(&data, endpoint).await?;
+		}
+		Subcommand::Claim => {
+			claim_smith_membership(&data).await?;
+		}
+		Subcommand::Renew => {
+			renew_smith_membership(&data).await?;
 		}
 		Subcommand::GoOnline => {
 			go_online(&data).await?;
@@ -58,7 +70,7 @@ pub async fn handle_command(data: Data, command: Subcommand) -> anyhow::Result<(
 		}
 		Subcommand::SudoSetKey { new_key } => {
 			data = data.build_client().await?;
-			commands::sudo::set_key(data.keypair(), data.client(), new_key).await?;
+			commands::sudo::set_key(&data, new_key).await?;
 		}
 		Subcommand::ShowExpire { blocks, sessions } => {
 			data = data.build_client().await?.build_indexer().await?;
@@ -68,6 +80,18 @@ pub async fn handle_command(data: Data, command: Subcommand) -> anyhow::Result<(
 			data = data.build_client().await?;
 			online(&data).await?
 		}
+		Subcommand::MemberCount => {
+			println!(
+				"smith member count: {:?}",
+				data.client()
+					.storage()
+					.fetch(
+						&runtime::storage().smith_membership().counter_for_membership(),
+						None,
+					)
+					.await?
+			)
+		}
 	};
 
 	Ok(())
@@ -104,6 +128,10 @@ pub async fn request_smith_membership(data: &Data, endpoint: String) -> Result<(
 			BaseExtrinsicParamsBuilder::new(),
 		)
 		.await?;
+
+	if data.args.no_wait {
+		return Ok(());
+	}
 	let events = track_progress(progress).await?;
 	let request = events.find_first::<runtime::smith_membership::events::MembershipRequested>()?;
 	if let Some(event) = request {
@@ -134,6 +162,9 @@ pub async fn update_session_keys(data: &Data) -> Result<(), GcliError> {
 	let session_keys = rotate_keys(data.client()).await?;
 	let progress = set_session_keys(data, session_keys).await?;
 
+	if data.args.no_wait {
+		return Ok(());
+	}
 	let _ = track_progress(progress).await?; // TODO
 	Ok(())
 }
@@ -155,40 +186,38 @@ pub async fn go_online(data: &Data) -> Result<(), GcliError> {
 		));
 	}
 
-	let progress = data
-		.client()
-		.tx()
-		.sign_and_submit_then_watch(
-			&runtime::tx().authority_members().go_online(),
-			&PairSigner::new(data.keypair()),
-			BaseExtrinsicParamsBuilder::new(),
-		)
-		.await?;
+	submit_call_and_look_event::<
+		runtime::authority_members::events::MemberGoOnline,
+		StaticTxPayload<runtime::authority_members::calls::GoOnline>,
+	>(data, &runtime::tx().authority_members().go_online())
+	.await.map_err(|e| e.into())
+}
 
-	let events = track_progress(progress).await?;
-	if let Some(e) = events.find_first::<runtime::authority_members::events::MemberGoOnline>()? {
-		println!("{e:?}");
-	}
-	Ok(())
+/// claim smith membership
+pub async fn claim_smith_membership(data: &Data) -> Result<(), subxt::Error> {
+	submit_call_and_look_event::<
+		runtime::smith_membership::events::MembershipAcquired,
+		StaticTxPayload<runtime::smith_membership::calls::ClaimMembership>,
+	>(data, &runtime::tx().smith_membership().claim_membership())
+	.await
+}
+
+/// renew smith membership
+pub async fn renew_smith_membership(data: &Data) -> Result<(), subxt::Error> {
+	submit_call_and_look_event::<
+		runtime::smith_membership::events::MembershipRenewed,
+		StaticTxPayload<runtime::smith_membership::calls::RenewMembership>,
+	>(data, &runtime::tx().smith_membership().renew_membership())
+	.await
 }
 
 /// submit go_offline
 pub async fn go_offline(data: &Data) -> Result<(), subxt::Error> {
-	let progress = data
-		.client()
-		.tx()
-		.sign_and_submit_then_watch(
-			&runtime::tx().authority_members().go_offline(),
-			&PairSigner::new(data.keypair()),
-			BaseExtrinsicParamsBuilder::new(),
-		)
-		.await?;
-	let events = track_progress(progress).await?;
-	if let Some(e) = events.find_first::<runtime::authority_members::events::MemberGoOffline>()? {
-		println!("{e:?}");
-	}
-
-	Ok(())
+	submit_call_and_look_event::<
+		runtime::authority_members::events::MemberGoOffline,
+		StaticTxPayload<runtime::authority_members::calls::GoOffline>,
+	>(data, &runtime::tx().authority_members().go_offline())
+	.await
 }
 
 /// get online authorities
@@ -286,6 +315,9 @@ pub async fn cert(data: &Data, receiver: u32) -> Result<(), anyhow::Error> {
 		)
 		.await?;
 
+	if data.args.no_wait {
+		return Ok(());
+	}
 	let events = track_progress(progress).await?;
 
 	// look for the expected event

src/commands/sudo.rs

 use crate::*;
 
 /// set sudo key
-pub async fn set_key(pair: Pair, client: &Client, new_key: AccountId) -> Result<(), subxt::Error> {
-	let progress = client
+pub async fn set_key(data: &Data, new_key: AccountId) -> Result<(), subxt::Error> {
+	let progress = data
+		.client()
 		.tx()
 		.sign_and_submit_then_watch(
 			&runtime::tx().sudo().set_key(new_key.into()),
-			&PairSigner::new(pair),
+			&PairSigner::new(data.keypair()),
 			BaseExtrinsicParamsBuilder::new(),
 		)
 		.await?;
 
+	if data.args.no_wait {
+		return Ok(());
+	}
 	let _ = track_progress(progress).await?; // TODO
 	Ok(())
 }

src/commands/transfer.rs

@@ -33,6 +33,9 @@ pub async fn transfer(
 			.await?
 	};
 
+	if data.args.no_wait {
+		return Ok(());
+	}
 	let events = track_progress(progress).await?;
 
 	if let Some(e) = events.find_first::<runtime::balances::events::Transfer>()? {
@@ -69,6 +72,9 @@ pub async fn transfer_multiple(
 		)
 		.await?;
 
+	if data.args.no_wait {
+		return Ok(());
+	}
 	let events = track_progress(progress).await?;
 	// TODO all transfer
 	if let Some(e) = events.find_first::<runtime::balances::events::Transfer>()? {

src/commands/ud.rs

@@ -34,6 +34,9 @@ pub async fn claim_ud(data: Data) -> Result<(), anyhow::Error> {
 		)
 		.await?;
 
+	if data.args.no_wait {
+		return Ok(());
+	}
 	let events = track_progress(progress).await?;
 
 	if let Some(e) = events.find_first::<runtime::universal_dividend::events::UdsClaimed>()? {

src/data.rs

@@ -157,8 +157,10 @@ impl Data {
 						let derivation = match &derivation[..] {
 							"test1" => "2",
 							"test2" => "4",
-							"test3" => "3",
-							_ => ""
+							"test3" => "6",
+							"test4" => "8",
+							"test5" => "10",
+							_ => "",
 						};
 						self.cfg.secret = Some(format!("{TEST_MNEMONIC}//{derivation}"));
 					} else {
@@ -173,21 +175,17 @@ impl Data {
 		// address
 		if let Some(address) = self.args.address.clone() {
 			self.cfg.address = Some(AccountId::from_str(&address).expect("invalid address"));
+			// if giving address, cancel secret
+			self.cfg.secret = None
 		}
 		self
 	}
 	/// build from config
 	pub fn build_from_config(mut self) -> Self {
-		// if a secret is defined, build keypair
+		// if a secret is defined, build keypair and silently overwrite address
 		if let Some(secret) = self.cfg.secret.clone() {
 			let (address, keypair) =
 				addr_and_pair_from_secret(SecretFormat::Predefined, &secret).unwrap();
-			// if an address is already defined and differs from secret, warns user
-			if let Some(address_) = self.cfg.address {
-				if address_ != address {
-					println!("overwriting address ({address_}) from secret ({address})");
-				}
-			}
 			self.cfg.address = Some(address);
 			self.cfg.secret = Some(secret);
 			self.keypair = Some(keypair);

src/main.rs

@@ -16,7 +16,8 @@ use runtime_config::*;
 use serde::Deserialize;
 use sp_core::{sr25519::Pair, Pair as _};
 use subxt::blocks::ExtrinsicEvents;
-use subxt::tx::{BaseExtrinsicParamsBuilder, PairSigner, TxStatus};
+use subxt::events::StaticEvent;
+use subxt::tx::{BaseExtrinsicParamsBuilder, PairSigner, TxPayload, TxStatus, StaticTxPayload};
 use utils::*;
 
 /// define command line arguments
@@ -48,6 +49,9 @@ pub struct Args {
 	/// Target network (local, gdev, gtest...)
 	#[clap(short, long)]
 	network: Option<String>,
+	/// prevent waiting for extrinsic completion
+	#[clap(long)]
+	no_wait: bool,
 }
 
 /// define subcommands
@@ -97,7 +101,7 @@ async fn main() -> Result<(), GcliError> {
 
 	// match subcommands
 	match data.args.subcommand.clone() {
-		Subcommand::DoNothing => {Ok(())}
+		Subcommand::DoNothing => Ok(()),
 		Subcommand::Account(subcommand) => {
 			commands::account::handle_command(data, subcommand).await
 		}
@@ -117,5 +121,6 @@ async fn main() -> Result<(), GcliError> {
 		}
 		Subcommand::Indexer(subcommand) => indexer::handle_command(data, subcommand).await,
 		Subcommand::Config(subcommand) => conf::handle_command(data, subcommand),
-	}.map_err(|e| dbg!(e).into())
+	}
+	.map_err(|e| dbg!(e).into())
 }

src/utils.rs

@@ -23,6 +23,32 @@ pub async fn track_progress(
 	.await
 }
 
+/// generic extrinsic submitter
+pub async fn submit_call_and_look_event<E: std::fmt::Debug + StaticEvent, Call: TxPayload>(
+	data: &Data,
+	call: &Call,
+) -> Result<(), subxt::Error> {
+	let progress = data
+		.client()
+		.tx()
+		.sign_and_submit_then_watch(
+			call,
+			&PairSigner::new(data.keypair()),
+			BaseExtrinsicParamsBuilder::new(),
+		)
+		.await?;
+
+	if data.args.no_wait {
+		return Ok(());
+	}
+	let events = track_progress(progress).await?;
+	if let Some(e) = events.find_first::<E>()? {
+		println!("{e:?}");
+	}
+
+	Ok(())
+}
+
 /// custom error type intended to provide more convenient error message to user
 #[derive(Debug)]
 pub enum GcliError {