removed notaries and govteam

Author: charlykeyko

fplus-cli/src/main.rs

@@ -14,14 +14,14 @@ fn cli() -> Command {
             Command::new("validate-trigger")
                 .about("Validates triggering an application")
                 .arg(arg!(<PR_NUMBER> "Pull Request Number"))
-                .arg(arg!(<GOV_GITHUB_HANDLE> "Github handle of Gov Team Member"))
+                .arg(arg!(<VERIFIER_GITHUB_HANDLE> "Github handle of Verifier"))
                 .arg_required_else_help(true),
         )
         .subcommand(
             Command::new("validate-proposal")
                 .about("Validates proposing an application")
                 .arg(arg!(<PR_NUMBER> "Pull Request Number"))
-                .arg(arg!(<Notary_GITHUB_HANDLE> "Github handle of Notary"))
+                .arg(arg!(<VERIFIER_GITHUB_HANDLE> "Github handle of Verifier"))
                 .arg_required_else_help(true),
         )
         .subcommand(
@@ -41,20 +41,20 @@ async fn main() -> std::io::Result<()> {
             let pull_request_number = sub_matches
                 .get_one::<String>("PR_NUMBER")
                 .expect("required");
-            let gov_gh_handle = sub_matches
-                .get_one::<String>("GOV_GITHUB_HANDLE")
+            let verifier_gh_handle = sub_matches
+                .get_one::<String>("VERIFIER_GITHUB_HANDLE")
                 .expect("required");
-            validate_trigger(gov_gh_handle.to_string(), pull_request_number.to_string()).await;
+            validate_trigger(verifier_gh_handle.to_string(), pull_request_number.to_string()).await;
         }
         Some(("validate-proposal", sub_matches)) => {
             let pull_request_number = sub_matches
                 .get_one::<String>("PR_NUMBER")
                 .expect("required");
-            let notary_gh_handle = sub_matches
-                .get_one::<String>("NOTARY_GITHUB_HANDLE")
+            let verifier_gh_handle = sub_matches
+                .get_one::<String>("VERIFIER_GITHUB_HANDLE")
                 .expect("required");
             validate_proposal(
-                notary_gh_handle.to_string(),
+                verifier_gh_handle.to_string(),
                 pull_request_number.to_string(),
             )
             .await;
@@ -63,11 +63,11 @@ async fn main() -> std::io::Result<()> {
             let pull_request_number = sub_matches
                 .get_one::<String>("PR_NUMBER")
                 .expect("required");
-            let notary_gh_handle = sub_matches
-                .get_one::<String>("NOTARY_GITHUB_HANDLE")
+            let verifier_gh_handle = sub_matches
+                .get_one::<String>("VERIFIER_GITHUB_HANDLE")
                 .expect("required");
             validate_approval(
-                notary_gh_handle.to_string(),
+                verifier_gh_handle.to_string(),
                 pull_request_number.to_string(),
             )
             .await;

fplus-cli/src/validators.rs

@@ -1,6 +1,6 @@
 pub async fn validate_trigger(github_handle: String, pull_request_number: String) -> bool {
     true
-    // if validate_gov_team_member(&github_handle).await {
+    // if validate_verifier(&github_handle).await {
     //     println!(
     //         "Validated Root Key Holder {} for application {}",
     //         &github_handle, pull_request_number
@@ -37,38 +37,20 @@ pub async fn validate_approval(github_handle: String, pull_request_number: Strin
     // }
 }
 
-async fn validate_gov_team_member(github_handle: &str) -> bool {
+async fn validate_verifier(github_handle: &str) -> bool {
     true
     // let db_connection: web::Data<Mutex<mongodb::Client>> = web::Data::new(Mutex::new(
     //     fplus_database::core::setup::setup().await.unwrap(),
     // ));
-    // let gov_team_members = fplus_database::core::collections::govteam::find(db_connection)
+    // let verifiers_list = fplus_database::core::collections::verifier::find(db_connection)
     //     .await
     //     .unwrap();
-    // let gov_team_members: Option<fplus_database::core::collections::govteam::GovTeamMember> = gov_team_members
+    // let verifiers_list: Option<fplus_database::core::collections::verifier::Verifier> = verifiers
     //     .into_iter()
     //     .find(|gov| &gov.github_handle == github_handle);
-    // if gov_team_members.is_none() {
+    // if verifiers_list.is_none() {
     //     false
     // } else {
     //     true
     // }
-}
-
-async fn validate_notary(github_handle: &str) -> bool {
-    true
-    // let db_connection: web::Data<Mutex<mongodb::Client>> = web::Data::new(Mutex::new(
-    //     fplus_database::core::setup::setup().await.unwrap(),
-    // ));
-    // let notary = fplus_database::core::collections::notary::find(db_connection)
-    //     .await
-    //     .unwrap();
-    // let notary: Option<fplus_database::core::collections::notary::Notary> = notary
-    //     .into_iter()
-    //     .find(|n| &n.github_handle == github_handle);
-    // if notary.is_none() {
-    //     false
-    // } else {
-    //     true
-    // }
-}
+}

fplus-http-server/src/main.rs

@@ -42,7 +42,7 @@ async fn main() -> std::io::Result<()> {
             .service(router::application::validate_application_approval)
             .service(router::blockchain::address_allowance)
             .service(router::blockchain::verified_clients)
-            .service(router::govteam::gov_team_members)
+            .service(router::verifier::verifiers)
             .service(router::allocator::allocators)
             .service(router::allocator::create)
             .service(router::allocator::update)

fplus-http-server/src/router/mod.rs

@@ -2,7 +2,7 @@ use actix_web::{get, HttpResponse, Responder};
 
 pub mod application;
 pub mod blockchain;
-pub mod govteam;
+pub mod verifier;
 pub mod allocator;
 
 /// Return server health status

fplus-http-server/src/router/govteam.rs renamed to fplus-http-server/src/router/verifier.rs

@@ -1,8 +1,8 @@
 use actix_web::{get, web, HttpResponse, Responder};
 use fplus_lib::core::{LDNApplication, GithubQueryParams};
 
-#[get("/gov-team-members")]
-pub async fn gov_team_members(query: web::Query<GithubQueryParams>) -> actix_web::Result<impl Responder> {
+#[get("/verifiers")]
+pub async fn verifiers(query: web::Query<GithubQueryParams>) -> actix_web::Result<impl Responder> {
     let GithubQueryParams { owner, repo } = query.into_inner();
 
     match LDNApplication::fetch_verifiers(owner, repo).await {

fplus-lib/src/core/application/allocation.rs

@@ -1,17 +1,17 @@
 use chrono::Utc;
 
 use super::file::{
-    Allocation, AllocationRequest, AllocationRequestType, Allocations, Notaries, Notary,
+    Allocation, AllocationRequest, AllocationRequestType, Allocations, Verifiers, Verifier,
 };
 
-impl Default for Notaries {
+impl Default for Verifiers {
     fn default() -> Self {
         Self(vec![])
     }
 }
 
-impl Notaries {
-    pub fn add(&self, signer: Notary) -> Self {
+impl Verifiers {
+    pub fn add(&self, signer: Verifier) -> Self {
         let mut res = self.0.clone();
         res.push(signer);
         Self(res)
@@ -44,7 +44,7 @@ impl Allocation {
             updated_at: Utc::now().to_string(),
             is_active: true,
             amount: request_information.allocation_amount,
-            signers: Notaries::default(),
+            signers: Verifiers::default(),
         }
     }
 }
@@ -100,7 +100,7 @@ impl Allocations {
         is_active
     }
 
-    pub fn add_signer(&self, request_id: String, signer: Notary) -> Self {
+    pub fn add_signer(&self, request_id: String, signer: Verifier) -> Self {
         let mut res: Vec<Allocation> = self.0.clone();
         for allocation in res.iter_mut() {
             if allocation.id == request_id && allocation.is_active {
@@ -111,7 +111,7 @@ impl Allocations {
         Self(res)
     }
 
-    pub fn add_signer_and_complete(&self, request_id: String, signer: Notary) -> Self {
+    pub fn add_signer_and_complete(&self, request_id: String, signer: Verifier) -> Self {
         let mut res: Vec<Allocation> = self.0.clone();
         for allocation in res.iter_mut() {
             if allocation.id == request_id && allocation.is_active {

fplus-lib/src/core/application/file.rs

@@ -299,11 +299,11 @@ pub struct Allocation {
     #[serde(rename = "Allocation Amount")]
     pub amount: String,
     #[serde(rename = "Signers")]
-    pub signers: Notaries,
+    pub signers: Verifiers,
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct Notaries(pub Vec<Notary>);
+pub struct Verifiers(pub Vec<Verifier>);
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct VerifierInput {
@@ -313,7 +313,7 @@ pub struct VerifierInput {
     pub message_cid: String,
 }
 
-impl From<VerifierInput> for Notary {
+impl From<VerifierInput> for Verifier {
     fn from(input: VerifierInput) -> Self {
         Self {
             github_username: input.github_username,
@@ -325,7 +325,7 @@ impl From<VerifierInput> for Notary {
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct Notary {
+pub struct Verifier {
     #[serde(rename = "Github Username")]
     pub github_username: String,
     #[serde(rename = "Signing Address")]
@@ -347,17 +347,16 @@ pub struct AllocationRequest {
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct ValidVerifierList {
-    pub gov_team: Vec<String>,
+    pub verifiers: Vec<String>,
 }
 
 impl ValidVerifierList {
     pub fn is_valid(&self, member: &str) -> bool {
-        self.gov_team.contains(&member.to_string())
+        self.verifiers.contains(&member.to_string())
     }
 }
 
 #[derive(Serialize)]
 pub struct LDNActorsResponse {
-    pub governance_gh_handles: Vec<String>,
-    pub notary_gh_handles: Vec<String>,
+    pub verifier_gh_handles: Vec<String>,
 }

fplus-lib/src/core/application/mod.rs

@@ -1,4 +1,4 @@
-use self::file::{AllocationRequest, Allocations, LifeCycle, Notary};
+use self::file::{AllocationRequest, Allocations, LifeCycle, Verifier};
 
 pub mod allocation;
 pub mod client;
@@ -77,7 +77,7 @@ impl file::ApplicationFile {
 
     pub fn add_signer_to_allocation(
         &self,
-        signer: Notary,
+        signer: Verifier,
         request_id: String,
         app_lifecycle: LifeCycle,
     ) -> Self {
@@ -91,7 +91,7 @@ impl file::ApplicationFile {
 
     pub fn add_signer_to_allocation_and_complete(
         &self,
-        signer: Notary,
+        signer: Verifier,
         request_id: String,
         app_lifecycle: LifeCycle,
     ) -> Self {

fplus-lib/src/core/mod.rs

@@ -36,7 +36,7 @@ pub struct CreateApplicationInfo {
 }
 
 #[derive(Deserialize, Serialize, Debug)]
-pub struct NotaryList(pub Vec<String>);
+pub struct VerifierList(pub Vec<String>);
 
 #[derive(Deserialize, Serialize, Debug)]
 pub struct CompleteNewApplicationProposalInfo {
@@ -611,22 +611,22 @@ impl LDNApplication {
     pub async fn fetch_verifiers(owner: String, repo: String) -> Result<ValidVerifierList, LDNError> {
         let allocator = database::get_allocator(&owner, &repo).await.map_err(|e| LDNError::Load(format!("Failed to retrieve allocators /// {}", e)))?;
 
-        let mut gov_team_handles = Vec::new();
+        let mut verifiers_handles = Vec::new();
 
         let allocator = match allocator {
             Some(a) => a,
             None => return Err(LDNError::Load("No allocator found".into())),
         };
 
         if let Some(handles) = allocator.verifiers_gh_handles {
-            gov_team_handles.extend(handles.split(',').map(String::from));
+            verifiers_handles.extend(handles.split(',').map(String::from));
         }
 
-        if gov_team_handles.is_empty() {
+        if verifiers_handles.is_empty() {
             return Err(LDNError::Load("No governance team found".into()));
         }
 
-        Ok(ValidVerifierList { gov_team: gov_team_handles })
+        Ok(ValidVerifierList { verifiers: verifiers_handles })
     }
 
     async fn single_merged(application_id: String, owner: String, repo: String) -> Result<(Content, ApplicationFile), LDNError> {
@@ -876,7 +876,7 @@ impl LDNApplication {
             let validated_at = application_file.lifecycle.validated_at.clone();
             let app_state = application_file.lifecycle.get_state();
             let active_request_id = application_file.lifecycle.active_request.clone();
-            let valid_gov_team = Self::fetch_verifiers(owner.clone(), repo.clone()).await?;
+            let valid_verifier_list = Self::fetch_verifiers(owner.clone(), repo.clone()).await?;
             let bot_user = get_env_var_or_default("BOT_USER", "filplus-allocators-staging-bot[bot]");
 
             let res: bool = match app_state {
@@ -910,8 +910,8 @@ impl LDNApplication {
                         } else if actor != bot_user {
                             log::warn!("- Not ready to sign - actor is not the bot user");
                             false
-                        } else if !valid_gov_team.is_valid(&validated_by) {
-                            log::warn!("- Not ready to sign - valid_gov_team is not valid");
+                        } else if !valid_verifier_list.is_valid(&validated_by) {
+                            log::warn!("- Not ready to sign - valid_verifier_list is not valid");
                             false
                         } else {
                             log::info!("- Validated!");
@@ -939,7 +939,7 @@ impl LDNApplication {
                 AppState::StartSignDatacap => {
                     if !validated_at.is_empty()
                         && !validated_by.is_empty()
-                        && valid_gov_team.is_valid(&validated_by)
+                        && valid_verifier_list.is_valid(&validated_by)
                     {
                         log::info!("- Validated!");
                         true
@@ -950,16 +950,16 @@ impl LDNApplication {
                         if validated_by.is_empty() {
                             log::warn!("- AppState: StartSignDatacap, validation failed: validated_by is empty");
                         }
-                        if !valid_gov_team.is_valid(&validated_by) {
-                            log::warn!("- AppState: StartSignDatacap, validation failed: valid_gov_team is not valid");
+                        if !valid_verifier_list.is_valid(&validated_by) {
+                            log::warn!("- AppState: StartSignDatacap, validation failed: valid_verifier_list is not valid");
                         }
                         false
                     }
                 }
                 AppState::Granted => {
                     if !validated_at.is_empty()
                         && !validated_by.is_empty()
-                        && valid_gov_team.is_valid(&validated_by)
+                        && valid_verifier_list.is_valid(&validated_by)
                     {
                         log::info!("- Application is granted");
                         true
@@ -974,9 +974,9 @@ impl LDNApplication {
                                 "- AppState: Granted, validation failed: validated_by is empty"
                             );
                         }
-                        if !valid_gov_team.is_valid(&validated_by) {
+                        if !valid_verifier_list.is_valid(&validated_by) {
                             log::warn!(
-                                "- AppState: Granted, validation failed: valid_gov_team is not valid"
+                                "- AppState: Granted, validation failed: valid_verifier_list is not valid"
                             );
                         }
                         false
@@ -1053,7 +1053,7 @@ impl LDNApplication {
                             return Ok(false);
                         }
                     };
-                    let signers: application::file::Notaries = active_request.signers.clone();
+                    let signers: application::file::Verifiers = active_request.signers.clone();
                     if signers.0.len() != 2 {
                         log::warn!("- Not enough signers");
                         return Ok(false);
@@ -1296,9 +1296,9 @@ impl LDNApplication {
             datacap_allocation_requested = allocation.amount.clone();
             id = allocation.id.clone();
 
-            if let Some(first_notary) = allocation.signers.0.get(0) {
-                signing_address = first_notary.signing_address.clone();
-                message_cid = first_notary.message_cid.clone();
+            if let Some(first_verifier) = allocation.signers.0.get(0) {
+                signing_address = first_verifier.signing_address.clone();
+                message_cid = first_verifier.message_cid.clone();
             }
         }