Changed to verifiers

Some notary and gov team cleanup

Author: kokal33

fplus-http-server/src/main.rs

@@ -42,8 +42,6 @@ async fn main() -> std::io::Result<()> {
             .service(router::application::validate_application_approval)
             .service(router::blockchain::address_allowance)
             .service(router::blockchain::verified_clients)
-            .service(router::notary::notaries)
-            .service(router::notary::ldn_actors)
             .service(router::govteam::gov_team_members)
             .service(router::allocator::allocators)
     })

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

@@ -3,7 +3,7 @@ use fplus_lib::core::LDNApplication;
 
 #[get("/gov-team-members")]
 pub async fn gov_team_members() -> actix_web::Result<impl Responder> {
-    match LDNApplication::fetch_gov().await {
+    match LDNApplication::fetch_verifiers().await {
         Ok(notaries) => {
             Ok(HttpResponse::Ok().json(notaries))
         }

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

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

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

@@ -29,3 +29,5 @@ tokio = { version = "1.32.0", features = ["rt", "macros"] }
 uuidv4 = "1.0.0"
 rayon = "1.8.0"
 log = "0.4.20"
+fplus-database = { path = "../fplus-database", version = "1.0.19"}
+

fplus-lib/Cargo.toml

@@ -2,7 +2,7 @@ use std::io::Cursor;
 
 use base64;
 
-use crate::core::application::file::{ApplicationFile, ValidNotaryList, ValidGovTeamList};
+use crate::core::application::file::{ApplicationFile, ValidVerifierList};
 
 pub fn decode(i: &str) -> Option<ApplicationFile> {
     let mut binding = Cursor::new(i);
@@ -13,23 +13,3 @@ pub fn decode(i: &str) -> Option<ApplicationFile> {
     };
     Some(app_file)
 }
-
-pub fn decode_notary(i: &str) -> Option<ValidNotaryList> {
-    let mut binding = Cursor::new(i);
-    let decoder = base64::read::DecoderReader::new(&mut binding, base64::STANDARD);
-    let notaries: ValidNotaryList = match serde_json::from_reader(decoder) {
-        Ok(f) => f,
-        Err(_) => return None,
-    };
-    Some(notaries)
-}
-
-pub fn decode_gov_team(i: &str) -> Option<ValidGovTeamList> {
-    let mut binding = Cursor::new(i);
-    let decoder = base64::read::DecoderReader::new(&mut binding, base64::STANDARD);
-    let gov_team: ValidGovTeamList = match serde_json::from_reader(decoder) {
-        Ok(f) => f,
-        Err(_) => return None,
-    };
-    Some(gov_team)
-}

fplus-lib/src/base64.rs

@@ -345,51 +345,12 @@ pub struct AllocationRequest {
     pub allocation_amount: String,
 }
 
-#[derive(Serialize, Deserialize, Clone, Debug)]
-pub struct NotaryConfig {
-    pub active_signer: bool,
-    pub signing_address: String,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct ValidNotary {
-    pub id: i32,
-    pub organization: String,
-    pub name: String,
-    pub election_round: String,
-    pub status: String,
-    pub use_case: String,
-    pub location: String,
-    pub notary_application_link: String,
-    pub website: String,
-    pub email: Vec<String>,
-    pub fil_slack_id: String,
-    pub github_user: Vec<String>,
-    pub ldn_config: NotaryConfig,
-    pub direct_config: NotaryConfig,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct ValidNotaryList {
-    pub notaries: Vec<ValidNotary>,
-}
-
-impl ValidNotaryList {
-    pub fn is_valid(&self, notary: &str) -> bool {
-        self.notaries
-            .iter()
-            .filter(|n| n.ldn_config.signing_address == notary)
-            .count()
-            > 0
-    }
-}
-
 #[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct ValidGovTeamList {
+pub struct ValidVerifierList {
     pub gov_team: Vec<String>,
 }
 
-impl ValidGovTeamList {
+impl ValidVerifierList {
     pub fn is_valid(&self, member: &str) -> bool {
         self.gov_team.contains(&member.to_string())
     }

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

@@ -20,11 +20,11 @@ use crate::{
 
 use self::application::file::{
     AllocationRequest, AllocationRequestType, AppState, ApplicationFile, NotaryInput,
-    ValidNotaryList, ValidGovTeamList,
+    ValidVerifierList,
 };
 use rayon::prelude::*;
 use crate::core::application::file::Allocation;
-
+use fplus_database::database;
 pub mod application;
 
 #[derive(Deserialize)]
@@ -518,43 +518,21 @@ impl LDNApplication {
         }
     }
 
-    pub async fn fetch_notaries() -> Result<ValidNotaryList, LDNError> {
-        let gh = GithubWrapper::new();
-        let notaries = gh
-            .get_file("data/notaries.json", "main")
-            .await
-            .map_err(|e| LDNError::Load(format!("Failed to retrieve notaries /// {}", e)))?;
-
-        let notaries = &notaries.items[0]
-            .content
-            .clone()
-            .and_then(|f| base64::decode_notary(&f.replace("\n", "")))
-            .and_then(|f| Some(f));
-        if let Some(notaries) = notaries {
-            return Ok(notaries.clone());
-        } else {
-            return Err(LDNError::Load(format!("Failed to retrieve notaries ///")));
+    pub async fn fetch_verifiers() -> Result<ValidVerifierList, LDNError> {
+        let allocators = database::get_allocators().await.map_err(|e| LDNError::Load(format!("Failed to retrieve allocators /// {}", e)))?;
+    
+        let mut gov_team_handles = Vec::new();
+        for allocator in allocators {
+            if let Some(handles) = allocator.verifiers_gh_handles {
+                gov_team_handles.extend(handles.split(',').map(String::from));
+            }
         }
-    }
-
-    pub async fn fetch_gov() -> Result<ValidGovTeamList, LDNError> {
-        let gh = GithubWrapper::new();
-        let gov_team = gh
-            .get_file("data/govteam.json", "main")
-            .await
-            .map_err(|e| LDNError::Load(format!("Failed to retrieve gov team /// {}", e)))?;
-
-        let gov_team = &gov_team.items[0]
-            .content
-            .clone()
-            .and_then(|f| base64::decode_gov_team(&f.replace("\n", "")))
-            .and_then(|f| Some(f));
-
-        if let Some(gov_team) = gov_team {
-            return Ok(gov_team.clone());
-        } else {
-            return Err(LDNError::Load(format!("Failed to retrieve gov team ///")));
+    
+        if gov_team_handles.is_empty() {
+            return Err(LDNError::Load("No governance team found".into()));
         }
+    
+        Ok(ValidVerifierList { gov_team: gov_team_handles })
     }
 
     async fn single_merged(application_id: String) -> Result<(Content, ApplicationFile), LDNError> {
@@ -802,7 +780,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_gov().await?;
+            let valid_gov_team = Self::fetch_verifiers().await?;
             let bot_user = get_env_var_or_default("BOT_USER", "filplus-github-bot-read-write[bot]");
 
             let res: bool = match app_state {
@@ -970,8 +948,8 @@ impl LDNApplication {
                     }
                     let signer = signers.0.get(1).unwrap();
                     let signer_address = signer.signing_address.clone();
-                    let valid_notaries = Self::fetch_notaries().await?;
-                    if valid_notaries.is_valid(&signer_address) {
+                    let valid_verifiers = Self::fetch_verifiers().await?;
+                    if valid_verifiers.is_valid(&signer_address) {
                         log::info!("- Validated!");
                         Self::issue_datacap_request_signature(application_file.clone(), "approved".to_string()).await?;
                         Self::update_issue_labels(application_file.issue_number.clone(), &[AppState::Granted.as_str()]).await?;
@@ -1021,8 +999,8 @@ impl LDNApplication {
                     }
                     let signer = signers.0.get(0).unwrap();
                     let signer_address = signer.signing_address.clone();
-                    let valid_notaries = Self::fetch_notaries().await?;
-                    if valid_notaries.is_valid(&signer_address) {
+                    let valid_verifiers = Self::fetch_verifiers().await?;
+                    if valid_verifiers.is_valid(&signer_address) {
                         Self::issue_start_sign_dc(application_file.issue_number.clone()).await?;
                         Self::issue_datacap_request_signature(application_file.clone(), "proposed".to_string()).await?;
                         Self::update_issue_labels(application_file.issue_number.clone(), &[AppState::StartSignDatacap.as_str()]).await?;
@@ -1298,25 +1276,6 @@ Your Datacap Allocation Request has been {} by the Notary
         Ok(true)
     }
 
-    pub async fn fetch_gov_and_notary_gh_users() -> Result<(Vec<String>, Vec<String>), LDNError> {
-        let gov_team_list = Self::fetch_gov()
-            .await
-            .map_err(|e| LDNError::Load(format!("Failed to retrieve gov team: {}", e)))?;
-
-        let notary_list = Self::fetch_notaries()
-            .await
-            .map_err(|e| LDNError::Load(format!("Failed to retrieve notaries: {}", e)))?;
-
-        let notary_gh_names = notary_list
-            .notaries
-            .into_iter()
-            .flat_map(|notary| notary.github_user)
-            .filter(|username| !username.is_empty())
-            .collect();
-
-        Ok((gov_team_list.gov_team, notary_gh_names))
-    }
-
     async fn add_error_label(issue_number: String, comment: String) -> Result<(), LDNError> {
         let gh = GithubWrapper::new();
         let num: u64 = issue_number.parse().expect("Not a valid integer");