bugfix twitter verification, add assertion a6, refactoring a2&a3 (#1307)

* bugfix: twitter verification, add a6

* bugfix retweet verification

* refactoring assertion a2&a3

Author: jingleizhang

pallets/vc-management/src/assertion.rs

@@ -30,10 +30,13 @@ pub type ParameterString = BoundedVec<u8, MaxStringLength>;
 #[derive(Encode, Decode, Clone, Debug, PartialEq, Eq, TypeInfo, MaxEncodedLen)]
 pub enum Assertion {
 	A1,
-	A2(ParameterString, ParameterString), // (guild_id, user_id)
-	A3(ParameterString, ParameterString), // (guild_id, user_id)
-	A4(Balance),                          // (minimum_amount)
-	A5(ParameterString, ParameterString), // (twitter_account, tweet_id)
+	A2(ParameterString),                                   // (guild_id)
+	A3(ParameterString, ParameterString, ParameterString), // (guild_id, channel_id, role_id)
+	A4(Balance),                                           // (minimum_amount)
+	A5(ParameterString, ParameterString),                  /* (twitter_account, tweet_id), -
+	                                                        * TODO: unsupported,
+	                                                        * until Twitter new API policy is
+	                                                        * published */
 	A6,
 	A7(Balance), // (minimum_amount)
 	A8,

pallets/vc-management/src/lib.rs

@@ -112,11 +112,13 @@ pub mod pallet {
 		// see https://github.com/litentry/litentry-parachain/issues/1275
 		HttpRequestFailed { reason: ErrorString },
 		RequestVCHandlingFailed,
+		ParseError,
 		Assertion1Failed,
 		Assertion2Failed,
 		Assertion3Failed,
 		Assertion4Failed,
 		Assertion5Failed,
+		Assertion6Failed,
 		Assertion7Failed,
 		Assertion8Failed,
 		Assertion10Failed,
@@ -215,11 +217,13 @@ pub mod pallet {
 					Self::deposit_event(Event::HttpRequestFailed { reason: s }),
 				VCMPError::RequestVCHandlingFailed =>
 					Self::deposit_event(Event::RequestVCHandlingFailed),
+				VCMPError::ParseError => Self::deposit_event(Event::ParseError),
 				VCMPError::Assertion1Failed => Self::deposit_event(Event::Assertion1Failed),
 				VCMPError::Assertion2Failed => Self::deposit_event(Event::Assertion2Failed),
 				VCMPError::Assertion3Failed => Self::deposit_event(Event::Assertion3Failed),
 				VCMPError::Assertion4Failed => Self::deposit_event(Event::Assertion4Failed),
 				VCMPError::Assertion5Failed => Self::deposit_event(Event::Assertion5Failed),
+				VCMPError::Assertion6Failed => Self::deposit_event(Event::Assertion6Failed),
 				VCMPError::Assertion7Failed => Self::deposit_event(Event::Assertion7Failed),
 				VCMPError::Assertion8Failed => Self::deposit_event(Event::Assertion8Failed),
 				VCMPError::Assertion10Failed => Self::deposit_event(Event::Assertion10Failed),

primitives/core/src/error.rs

@@ -55,16 +55,17 @@ impl frame_support::traits::PalletError for IMPError {
 #[derive(Encode, Decode, Clone, Debug, PartialEq, Eq, TypeInfo, MaxEncodedLen)]
 pub enum VCMPError {
 	HttpRequestFailed(ErrorString),
-
 	// Indirect call handling errors when importing parachain blocks
 	RequestVCHandlingFailed,
-
+	// UTF8Error
+	ParseError,
 	// Assertion
 	Assertion1Failed,
 	Assertion2Failed,
 	Assertion3Failed,
 	Assertion4Failed,
 	Assertion5Failed,
+	Assertion6Failed,
 	Assertion7Failed,
 	Assertion8Failed,
 	Assertion10Failed,

tee-worker/litentry/core/assertion-build/src/a2.rs

@@ -24,7 +24,7 @@ use crate::Result;
 use itp_stf_primitives::types::ShardIdentifier;
 use itp_types::AccountId;
 use lc_credentials::Credential;
-use lc_data_providers::discord_litentry::DiscordLitentryClient;
+use lc_data_providers::{discord_litentry::DiscordLitentryClient, vec_to_string};
 use litentry_primitives::{
 	Assertion, Identity, ParameterString, ParentchainBlockNumber, Web2Network,
 };
@@ -35,55 +35,54 @@ use std::vec::Vec;
 pub fn build(
 	identities: Vec<Identity>,
 	guild_id: ParameterString,
-	handler: ParameterString,
 	shard: &ShardIdentifier,
 	who: &AccountId,
 	bn: ParentchainBlockNumber,
 ) -> Result<Credential> {
 	let mut discord_cnt: i32 = 0;
 	let mut has_joined: bool = false;
 
+	let guild_id_s = vec_to_string(guild_id.to_vec()).map_err(|_| VCMPError::ParseError)?;
+
 	let mut client = DiscordLitentryClient::new();
 	for identity in identities {
-		if let Identity::Web2 { network, address: _addr } = identity {
+		if let Identity::Web2 { network, address } = identity {
 			if matches!(network, Web2Network::Discord) {
 				discord_cnt += 1;
-				if let Ok(response) = client.check_join(guild_id.to_vec(), handler.to_vec()) {
+				if let Ok(response) = client.check_join(guild_id.to_vec(), address.to_vec()) {
 					if response.data {
 						has_joined = true;
-						break
+
+						//Assign role "ID-Hubber" to each discord account
+						if let Ok(response) =
+							client.assign_id_hubber(guild_id.to_vec(), address.to_vec())
+						{
+							if !response.data {
+								error!(
+									"assign_id_hubber {} {}",
+									response.message, response.msg_code
+								);
+							}
+						}
 					}
 				}
 			}
 		}
 	}
 
 	match Credential::generate_unsigned_credential(
-		&Assertion::A2(guild_id.clone(), handler.clone()),
+		&Assertion::A2(guild_id),
 		who,
 		&shard.clone(),
 		bn,
 	) {
 		Ok(mut credential_unsigned) => {
 			if discord_cnt > 0 && has_joined {
 				credential_unsigned.credential_subject.values.push(true);
-
-				//Assign Role "ID-Hubber" to User
-				match client.assign_id_hubber(guild_id.to_vec(), handler.to_vec()) {
-					Ok(response) => {
-						//check response
-						if !response.data {
-							error!("assign_id_hubber {} {}", response.message, response.msg_code);
-						}
-					},
-					Err(e) => {
-						error!("assign_id_hubber failed {:?}", e);
-						return Err(VCMPError::Assertion2Failed)
-					},
-				}
 			} else {
 				credential_unsigned.credential_subject.values.push(false);
 			}
+			credential_unsigned.add_assertion_a2(guild_id_s);
 			return Ok(credential_unsigned)
 		},
 		Err(e) => {
@@ -110,19 +109,20 @@ mod tests {
 			.write()
 			.unwrap()
 			.set_discord_litentry_url("http://localhost:9527".to_string());
-		let guildid: u64 = 919848390156767232;
-		let guild_id_vec: Vec<u8> = format!("{}", guildid).as_bytes().to_vec();
+		let guild_id_u: u64 = 919848390156767232;
+		let guild_id_vec: Vec<u8> = format!("{}", guild_id_u).as_bytes().to_vec();
+
 		let handler_vec: Vec<u8> = "againstwar%234779".to_string().as_bytes().to_vec();
 		let identities = vec![Identity::Web2 {
 			network: Web2Network::Discord,
 			address: IdentityString::truncate_from(handler_vec.clone()),
 		}];
+
 		let guild_id = BoundedVec::try_from(guild_id_vec).unwrap();
-		let handler = BoundedVec::try_from(handler_vec).unwrap();
 		let who = AccountId::from([0; 32]);
 		let shard = ShardIdentifier::default();
 
-		let _ = build(identities, guild_id, handler, &shard, &who, 1);
+		let _ = build(identities, guild_id, &shard, &who, 1);
 		log::info!("assertion2 test");
 	}
 }

tee-worker/litentry/core/assertion-build/src/a3.rs

@@ -24,7 +24,7 @@ use crate::Result;
 use itp_stf_primitives::types::ShardIdentifier;
 use itp_types::AccountId;
 use lc_credentials::Credential;
-use lc_data_providers::discord_litentry::DiscordLitentryClient;
+use lc_data_providers::{discord_litentry::DiscordLitentryClient, vec_to_string};
 use litentry_primitives::{
 	Assertion, Identity, ParameterString, ParentchainBlockNumber, Web2Network,
 };
@@ -35,18 +35,28 @@ use std::vec::Vec;
 pub fn build(
 	identities: Vec<Identity>,
 	guild_id: ParameterString,
-	handler: ParameterString,
+	channel_id: ParameterString,
+	role_id: ParameterString,
 	shard: &ShardIdentifier,
 	who: &AccountId,
 	bn: ParentchainBlockNumber,
 ) -> Result<Credential> {
 	let mut has_commented: bool = false;
 
+	let guild_id_s = vec_to_string(guild_id.to_vec()).map_err(|_| VCMPError::ParseError)?;
+	let channel_id_s = vec_to_string(channel_id.to_vec()).map_err(|_| VCMPError::ParseError)?;
+	let role_id_s = vec_to_string(role_id.to_vec()).map_err(|_| VCMPError::ParseError)?;
+
 	let mut client = DiscordLitentryClient::new();
 	for identity in identities {
-		if let Identity::Web2 { network, address: _addr } = identity {
+		if let Identity::Web2 { network, address } = identity {
 			if matches!(network, Web2Network::Discord) {
-				if let Ok(response) = client.check_id_hubber(guild_id.to_vec(), handler.to_vec()) {
+				if let Ok(response) = client.check_id_hubber(
+					guild_id.to_vec(),
+					channel_id.to_vec(),
+					role_id.to_vec(),
+					address.to_vec(),
+				) {
 					if response.data {
 						has_commented = true;
 						break
@@ -57,7 +67,7 @@ pub fn build(
 	}
 
 	match Credential::generate_unsigned_credential(
-		&Assertion::A3(guild_id, handler),
+		&Assertion::A3(guild_id, channel_id, role_id),
 		who,
 		&shard.clone(),
 		bn,
@@ -68,6 +78,7 @@ pub fn build(
 			} else {
 				credential_unsigned.credential_subject.values.push(false);
 			}
+			credential_unsigned.add_assertion_a3(guild_id_s, channel_id_s, role_id_s);
 			Ok(credential_unsigned)
 		},
 		Err(e) => {
@@ -94,19 +105,27 @@ mod tests {
 			.write()
 			.unwrap()
 			.set_discord_litentry_url("http://localhost:9527".to_string());
-		let guildid: u64 = 919848390156767232;
-		let guild_id_vec: Vec<u8> = format!("{}", guildid).as_bytes().to_vec();
-		let handler_vec: Vec<u8> = "ericzhang.eth#0114".to_string().as_bytes().to_vec();
+		let guild_id_u: u64 = 919848390156767232;
+		let channel_id_u: u64 = 919848392035794945;
+		let role_id_u: u64 = 1034083718425493544;
+
+		let guild_id_vec: Vec<u8> = format!("{}", guild_id_u).as_bytes().to_vec();
+		let channel_id_vec: Vec<u8> = format!("{}", channel_id_u).as_bytes().to_vec();
+		let role_id_vec: Vec<u8> = format!("{}", role_id_u).as_bytes().to_vec();
+
+		let handler_vec: Vec<u8> = "againstwar%234779".to_string().as_bytes().to_vec();
 		let identities = vec![Identity::Web2 {
 			network: Web2Network::Discord,
 			address: IdentityString::truncate_from(handler_vec.clone()),
 		}];
+
 		let guild_id = BoundedVec::try_from(guild_id_vec).unwrap();
-		let handler = BoundedVec::try_from(handler_vec).unwrap();
+		let channel_id = BoundedVec::try_from(channel_id_vec).unwrap();
+		let role_id = BoundedVec::try_from(role_id_vec).unwrap();
 		let who = AccountId::from([0; 32]);
 		let shard = ShardIdentifier::default();
 
-		let _ = build(identities, guild_id, handler, &shard, &who, 1);
+		let _ = build(identities, guild_id, channel_id, role_id, &shard, &who, 1);
 		log::info!("assertion3 test");
 	}
 }

tee-worker/litentry/core/assertion-build/src/a6.rs

@@ -20,9 +20,14 @@ compile_error!("feature \"std\" and feature \"sgx\" cannot be enabled at the sam
 #[cfg(all(not(feature = "std"), feature = "sgx"))]
 extern crate sgx_tstd as std;
 
-use crate::Error;
+use crate::Result;
+use itp_stf_primitives::types::ShardIdentifier;
+use itp_types::AccountId;
+use lc_credentials::Credential;
 use lc_data_providers::twitter_official::TwitterOfficialClient;
-use litentry_primitives::{Identity, Web2Network};
+use litentry_primitives::{Assertion, Identity, ParentchainBlockNumber, Web2Network};
+use log::*;
+use parachain_core_primitives::VCMPError;
 use std::vec::Vec;
 
 /// Following ranges:
@@ -32,39 +37,73 @@ use std::vec::Vec;
 ///    * 1,000+ followers
 ///    * 10,000+ followers
 ///    * 100,000+ followers
-pub fn build(identities: Vec<Identity>) -> Result<(), Error> {
+pub fn build(
+	identities: Vec<Identity>,
+	shard: &ShardIdentifier,
+	who: &AccountId,
+	bn: ParentchainBlockNumber,
+) -> Result<Credential> {
 	let mut client = TwitterOfficialClient::new();
 	let mut sum: u32 = 0;
+
 	for identity in identities {
 		if let Identity::Web2 { network, address } = identity {
 			if matches!(network, Web2Network::Twitter) {
-				let twitter_id = address.to_vec();
-				match client.query_user(twitter_id) {
-					Ok(user) => sum += user.public_metrics.followers_count,
-					Err(e) => log::warn!("Assertion6 request error:{:?}", e),
+				let twitter_handler = address.to_vec();
+				match client.query_user(twitter_handler) {
+					Ok(user) =>
+						if let Some(metrics) = user.public_metrics {
+							sum += metrics.followers_count;
+						},
+					Err(e) => {
+						log::warn!("Assertion6 request error:{:?}", e);
+						return Err(VCMPError::Assertion6Failed)
+					},
 				}
 			}
 		}
 	}
+
+	info!("sum followers: {}", sum);
+	let min: u64;
+	let max: u64;
+
 	match sum {
 		0 | 1 => {
-			log::warn!("level 0");
+			min = 0;
+			max = 1;
 		},
 		2..=100 => {
-			log::warn!("level 1");
+			min = 1;
+			max = 100;
 		},
 		101..=1000 => {
-			log::warn!("level 2");
+			min = 100;
+			max = 1000;
 		},
 		1001..=10000 => {
-			log::warn!("level 3");
+			min = 1000;
+			max = 10000;
 		},
 		10001..=100000 => {
-			log::warn!("level 4");
+			min = 10000;
+			max = 100000;
 		},
 		100001..=u32::MAX => {
-			log::warn!("level 5");
+			min = 100000;
+			max = u64::MAX;
+		},
+	}
+
+	match Credential::generate_unsigned_credential(&Assertion::A6, who, &shard.clone(), bn) {
+		Ok(mut credential_unsigned) => {
+			credential_unsigned.add_assertion_a6(min, max);
+			credential_unsigned.credential_subject.values.push(true);
+			return Ok(credential_unsigned)
+		},
+		Err(e) => {
+			error!("Generate unsigned credential failed {:?}", e);
 		},
 	}
-	Ok(())
+	Err(VCMPError::Assertion6Failed)
 }