[cli] improve democracy + commitments commands (#368)

* add tally counts and thresholds

* cosmetics

* add reputation commitment commands

* cleanup

* bump version 1.8.3

Author: brenzi

Cargo.lock

@@ -3,7 +3,7 @@ name = "encointer-client-notee"
 authors = ["encointer.org <alain@encointer.org>"]
 edition = "2021"
 #keep with node version. major, minor and patch
-version = "1.8.2"
+version = "1.8.3"
 
 [dependencies]
 # todo migrate to clap >=3 https://github.com/encointer/encointer-node/issues/107

client/Cargo.toml

@@ -1,11 +1,28 @@
 use crate::{Api, Moment, Result};
+use encointer_node_notee_runtime::Hash;
+use encointer_primitives::{
+	ceremonies::ReputationCountType,
+	democracy::{ProposalIdType, Tally},
+	reputation_commitments::PurposeIdType,
+};
 use std::time::Duration;
 use substrate_api_client::GetStorage;
 
 #[maybe_async::maybe_async(?Send)]
 pub trait DemocracyApi {
 	async fn get_proposal_lifetime(&self) -> Result<Duration>;
 	async fn get_confirmation_period(&self) -> Result<Duration>;
+	async fn get_min_turnout(&self) -> Result<ReputationCountType>;
+	async fn get_tally(
+		&self,
+		proposal_id: ProposalIdType,
+		maybe_at: Option<Hash>,
+	) -> Result<Option<Tally>>;
+	async fn get_purpose_id(
+		&self,
+		proposal_id: ProposalIdType,
+		maybe_at: Option<Hash>,
+	) -> Result<Option<PurposeIdType>>;
 }
 
 #[maybe_async::maybe_async(?Send)]
@@ -20,4 +37,24 @@ impl DemocracyApi for Api {
 			self.get_constant::<Moment>("EncointerDemocracy", "ConfirmationPeriod").await?,
 		))
 	}
+	async fn get_min_turnout(&self) -> Result<ReputationCountType> {
+		self.get_constant("EncointerDemocracy", "MinTurnout").await
+	}
+	async fn get_tally(
+		&self,
+		proposal_id: ProposalIdType,
+		maybe_at: Option<Hash>,
+	) -> Result<Option<Tally>> {
+		self.get_storage_map("EncointerDemocracy", "Tallies", proposal_id, maybe_at)
+			.await
+	}
+
+	async fn get_purpose_id(
+		&self,
+		proposal_id: ProposalIdType,
+		maybe_at: Option<Hash>,
+	) -> Result<Option<PurposeIdType>> {
+		self.get_storage_map("EncointerDemocracy", "PurposeIds", proposal_id, maybe_at)
+			.await
+	}
 }

client/encointer-api-client-extension/src/democracy.rs

@@ -21,11 +21,13 @@ pub use ceremonies::*;
 pub use communities::*;
 pub use democracy::*;
 pub use extrinsic_params::*;
+pub use reputation_commitments::*;
 pub use scheduler::*;
 
 mod bazaar;
 mod ceremonies;
 mod communities;
 mod democracy;
 mod extrinsic_params;
+mod reputation_commitments;
 mod scheduler;

client/encointer-api-client-extension/src/lib.rs

@@ -0,0 +1,58 @@
+use crate::{Api, Result};
+use encointer_node_notee_runtime::{AccountId, Hash};
+use encointer_primitives::{
+	ceremonies::CommunityCeremony,
+	reputation_commitments::{DescriptorType, PurposeIdType},
+};
+use substrate_api_client::GetStorage;
+
+#[maybe_async::maybe_async(?Send)]
+pub trait ReputationCommitmentsApi {
+	async fn get_commitment(
+		&self,
+		community_ceremony: &CommunityCeremony,
+		purpose_account: (PurposeIdType, AccountId),
+		maybe_at: Option<Hash>,
+	) -> Result<Option<Option<Hash>>>;
+	async fn get_current_purpose_id(&self, maybe_at: Option<Hash>)
+		-> Result<Option<PurposeIdType>>;
+	async fn get_purpose_descriptor(
+		&self,
+		purpose_id: PurposeIdType,
+		maybe_at: Option<Hash>,
+	) -> Result<Option<DescriptorType>>;
+}
+
+#[maybe_async::maybe_async(?Send)]
+impl ReputationCommitmentsApi for Api {
+	async fn get_commitment(
+		&self,
+		community_ceremony: &CommunityCeremony,
+		purpose_account: (PurposeIdType, AccountId),
+		maybe_at: Option<Hash>,
+	) -> Result<Option<Option<Hash>>> {
+		self.get_storage_double_map(
+			"EncointerReputationCommitments",
+			"Commitments",
+			community_ceremony,
+			purpose_account,
+			maybe_at,
+		)
+		.await
+	}
+	async fn get_current_purpose_id(
+		&self,
+		maybe_at: Option<Hash>,
+	) -> Result<Option<PurposeIdType>> {
+		self.get_storage("EncointerReputationCommitments", "CurrentPurposeId", maybe_at)
+			.await
+	}
+	async fn get_purpose_descriptor(
+		&self,
+		purpose_id: PurposeIdType,
+		maybe_at: Option<Hash>,
+	) -> Result<Option<DescriptorType>> {
+		self.get_storage_map("EncointerReputationCommitments", "Purposes", purpose_id, maybe_at)
+			.await
+	}
+}

client/encointer-api-client-extension/src/reputation_commitments.rs

@@ -1,5 +1,5 @@
 use clap::{App, Arg, ArgMatches};
-use encointer_primitives::balances::BalanceType;
+use encointer_primitives::{balances::BalanceType, reputation_commitments::PurposeIdType};
 use sp_core::{bytes, H256 as Hash};
 
 const ACCOUNT_ARG: &str = "accountid";
@@ -35,6 +35,8 @@ const REPUTATION_VEC_ARG: &str = "reputation-vec";
 const INACTIVITY_TIMEOUT_ARG: &str = "inactivity-timeout";
 const NOMINAL_INCOME_ARG: &str = "nominal-income";
 
+const PURPOSE_ID_ARG: &str = "purpose-id";
+
 pub trait EncointerArgs<'b> {
 	fn account_arg(self) -> Self;
 	fn faucet_account_arg(self) -> Self;
@@ -70,6 +72,7 @@ pub trait EncointerArgs<'b> {
 	fn reputation_vec_arg(self) -> Self;
 	fn inactivity_timeout_arg(self) -> Self;
 	fn nominal_income_arg(self) -> Self;
+	fn purpose_id_arg(self) -> Self;
 }
 
 pub trait EncointerArgsExtractor {
@@ -106,6 +109,7 @@ pub trait EncointerArgsExtractor {
 	fn reputation_vec_arg(&self) -> Option<Vec<&str>>;
 	fn inactivity_timeout_arg(&self) -> Option<u32>;
 	fn nominal_income_arg(&self) -> Option<BalanceType>;
+	fn purpose_id_arg(&self) -> Option<PurposeIdType>;
 }
 
 impl<'a, 'b> EncointerArgs<'b> for App<'a, 'b> {
@@ -432,6 +436,15 @@ impl<'a, 'b> EncointerArgs<'b> for App<'a, 'b> {
 				.help("nominal income"),
 		)
 	}
+	fn purpose_id_arg(self) -> Self {
+		self.arg(
+			Arg::with_name(PURPOSE_ID_ARG)
+				.takes_value(true)
+				.required(false)
+				.value_name("PURPOSE_ID")
+				.help("reputation commitment purpose id"),
+		)
+	}
 }
 
 impl<'a> EncointerArgsExtractor for ArgMatches<'a> {
@@ -553,4 +566,7 @@ impl<'a> EncointerArgsExtractor for ArgMatches<'a> {
 		self.value_of(NOMINAL_INCOME_ARG)
 			.map(|v| BalanceType::from_num(v.parse::<f64>().unwrap()))
 	}
+	fn purpose_id_arg(&self) -> Option<PurposeIdType> {
+		self.value_of(PURPOSE_ID_ARG).map(|v| v.parse().unwrap())
+	}
 }

client/src/cli_args.rs

@@ -97,6 +97,7 @@ pub fn list_proposals(_args: &str, matches: &ArgMatches<'_>) -> Result<(), clap:
 		}
 		let confirmation_period = api.get_confirmation_period().await.unwrap();
 		let proposal_lifetime = api.get_proposal_lifetime().await.unwrap();
+		let min_turnout_permill = api.get_min_turnout().await.unwrap();
 		for storage_key in storage_keys.iter() {
 			let key_postfix = storage_key.as_ref();
 			let proposal_id =
@@ -107,7 +108,6 @@ pub fn list_proposals(_args: &str, matches: &ArgMatches<'_>) -> Result<(), clap:
 			if !matches.all_flag() && matches!(proposal.state, ProposalState::Cancelled) {
 				continue
 			}
-			println!("id: {}", proposal_id);
 			let start = DateTime::<Utc>::from_timestamp_millis(
 				TryInto::<i64>::try_into(proposal.start).unwrap(),
 			)
@@ -134,18 +134,37 @@ pub fn list_proposals(_args: &str, matches: &ArgMatches<'_>) -> Result<(), clap:
 				maybe_at,
 			)
 			.await;
-			println!("action: {:?}", proposal.action);
-			println!("started at: {}", start.format("%Y-%m-%d %H:%M:%S %Z").to_string());
+			let tally = api.get_tally(proposal_id, maybe_at).await.unwrap().unwrap_or_default();
+			let purpose_id = api.get_purpose_id(proposal_id, maybe_at).await.unwrap().unwrap();
 			println!(
-				"ends after: {}",
+				"Proposal id: {} (reputation commitment purpose id: {})",
+				proposal_id, purpose_id
+			);
+			println!("🛠 action: {:?}", proposal.action);
+			println!("▶️ started at: {}", start.format("%Y-%m-%d %H:%M:%S %Z").to_string());
+			println!(
+				"🏁 ends after: {}",
 				(start + proposal_lifetime.clone()).format("%Y-%m-%d %H:%M:%S %Z").to_string()
 			);
-			println!("start cindex: {}", proposal.start_cindex);
-			println!("current electorate estimate: {electorate}");
+			println!("🔄 start cindex: {}", proposal.start_cindex);
+			println!("👥 electorate: {electorate}");
+			println!(
+				"🗳 turnout: {} votes = {:.3}% of electorate (turnout threshold {} votes = {:.3}%)",
+				tally.turnout,
+				100f64 * tally.turnout as f64 / electorate as f64,
+				min_turnout_permill as f64 * electorate as f64 / 1000f64,
+				min_turnout_permill as f64 / 10f64
+			);
+			println!(
+				"🗳 approval: {} votes = {:.3}% Aye (AQB approval threshold: {:.3}%)",
+				tally.ayes,
+				100f64 * tally.ayes as f64 / tally.turnout as f64,
+				approval_threshold_percent(electorate, tally.turnout)
+			);
 			println!("state: {:?}", proposal.state);
 			if let Some(since) = maybe_confirming_since {
 				println!(
-					"confirming since: {} until {}",
+					"👍 confirming since: {} until {}",
 					since.format("%Y-%m-%d %H:%M:%S %Z").to_string(),
 					(since + confirmation_period).format("%Y-%m-%d %H:%M:%S %Z").to_string()
 				)
@@ -293,3 +312,7 @@ async fn get_relevant_electorate(
 		panic!("couldn't fetch some values")
 	}
 }
+
+fn approval_threshold_percent(electorate: u128, turnout: u128) -> f64 {
+	100f64 / (1f64 + (turnout as f64 / electorate as f64).sqrt())
+}

client/src/commands/encointer_democracy.rs

@@ -0,0 +1,115 @@
+use crate::{cli_args::EncointerArgsExtractor, utils::get_chain_api};
+use clap::ArgMatches;
+use encointer_api_client_extension::{
+	CeremoniesApi, CommunitiesApi, ReputationCommitmentsApi, SchedulerApi,
+};
+use encointer_node_notee_runtime::{AccountId, Hash};
+use encointer_primitives::reputation_commitments::{DescriptorType, PurposeIdType};
+use log::{debug, error};
+use parity_scale_codec::{Decode, Encode};
+use sp_core::crypto::Ss58Codec;
+use substrate_api_client::GetStorage;
+
+pub fn list_commitments(_args: &str, matches: &ArgMatches<'_>) -> Result<(), clap::Error> {
+	let rt = tokio::runtime::Runtime::new().unwrap();
+	rt.block_on(async {
+		let api = get_chain_api(matches).await;
+		let maybe_at = matches.at_block_arg();
+		let cid = api.verify_cid(matches.cid_arg().unwrap(), None).await;
+		let maybe_purpose_id = matches.purpose_id_arg();
+		let cindex = api.get_ceremony_index(None).await;
+		if let Ok((reputation_lifetime, max_purpose_id)) = tokio::try_join!(
+			api.get_reputation_lifetime(maybe_at),
+			api.get_current_purpose_id(maybe_at)
+		) {
+			let relevant_cindexes = cindex.saturating_sub(reputation_lifetime)..=cindex;
+			debug!("relevant ceremony indexes: {:?}", &relevant_cindexes);
+			let pids = match maybe_purpose_id {
+				Some(pid) => pid..=pid,
+				_ => 0..=max_purpose_id.unwrap_or(0),
+			};
+			debug!("scanning for purpose_id's: {:?}", pids);
+			for purpose_id in pids {
+				for c in relevant_cindexes.clone() {
+					let mut key_prefix = api
+						.get_storage_double_map_key_prefix(
+							"EncointerReputationCommitments",
+							"Commitments",
+							(cid, c),
+						)
+						.await
+						.unwrap();
+
+					// thanks to Identity hashing we can get all accounts for one specific PurposeId and community_ceremony
+					key_prefix.0.append(&mut purpose_id.encode());
+
+					let max_keys = 1000;
+					let storage_keys = api
+						.get_storage_keys_paged(Some(key_prefix), max_keys, None, maybe_at)
+						.await
+						.unwrap();
+					if storage_keys.len() == max_keys as usize {
+						error!("results can be wrong because max keys reached for query")
+					}
+					for storage_key in storage_keys.iter() {
+						let maybe_commitment: Option<Option<Hash>> =
+							api.get_storage_by_key(storage_key.clone(), maybe_at).await.unwrap();
+						if let Some(maybe_hash) = maybe_commitment {
+							let account = AccountId::decode(
+								&mut storage_key.0[storage_key.0.len() - 32..].as_ref(),
+							)
+							.unwrap();
+							if let Some(hash) = maybe_hash {
+								println!(
+									"{cid}, {c}, {purpose_id}, {}, {}",
+									account.to_ss58check(),
+									hash
+								);
+							} else {
+								println!(
+									"{cid}, {c}, {purpose_id}, {}, None",
+									account.to_ss58check()
+								);
+							}
+						}
+					}
+				}
+			}
+		}
+		Ok(())
+	})
+	.into()
+}
+
+pub fn list_purposes(_args: &str, matches: &ArgMatches<'_>) -> Result<(), clap::Error> {
+	let rt = tokio::runtime::Runtime::new().unwrap();
+	rt.block_on(async {
+		let api = get_chain_api(matches).await;
+		let maybe_at = matches.at_block_arg();
+		let key_prefix = api
+			.get_storage_map_key_prefix("EncointerReputationCommitments", "Purposes")
+			.await
+			.unwrap();
+
+		let max_keys = 1000;
+		let storage_keys = api
+			.get_storage_keys_paged(Some(key_prefix), max_keys, None, maybe_at)
+			.await
+			.unwrap();
+		if storage_keys.len() == max_keys as usize {
+			error!("results can be wrong because max keys reached for query")
+		}
+		for storage_key in storage_keys.iter() {
+			let maybe_purpose: Option<DescriptorType> =
+				api.get_storage_by_key(storage_key.clone(), maybe_at).await.unwrap();
+			if let Some(descriptor) = maybe_purpose {
+				let purpose_id =
+					PurposeIdType::decode(&mut storage_key.0[storage_key.0.len() - 8..].as_ref())
+						.unwrap();
+				println!("{purpose_id}: {}", String::from_utf8_lossy(descriptor.as_ref()));
+			}
+		}
+		Ok(())
+	})
+	.into()
+}