[Feat]:: Implemented "Ban Expert" Logic

contracts/identity-registry-contract/src/contract.rs

@@ -3,6 +3,7 @@ use crate::storage;
 use crate::events;
 use crate::{error::RegistryError, types::ExpertStatus};
 
+/// Initialize the registry with an admin address
 pub fn initialize_registry(env: &Env, admin: &Address) -> Result<(), RegistryError> {
     if storage::has_admin(env) {
         return Err(RegistryError::AlreadyInitialized);
@@ -13,6 +14,7 @@ pub fn initialize_registry(env: &Env, admin: &Address) -> Result<(), RegistryErr
     Ok(())
 }
 
+/// Verify an expert by setting their status to Verified (Admin only)
 /// Batch Verification
 pub fn batch_add_experts(env:Env, experts: Vec<Address>) -> Result<(), RegistryError> {
     if experts.len() > 20 {
@@ -36,18 +38,53 @@ pub fn batch_add_experts(env:Env, experts: Vec<Address>) -> Result<(), RegistryE
 
 pub fn verify_expert(env: &Env, expert: &Address) -> Result<(), RegistryError> {
     let admin = storage::get_admin(env).ok_or(RegistryError::NotInitialized)?;
-    
+
     admin.require_auth();
-    
+
     let current_status = storage::get_expert_status(env, expert);
-    
+
     if current_status == ExpertStatus::Verified {
         return Err(RegistryError::AlreadyVerified);
     }
-    
+
     storage::set_expert_record(env, expert, ExpertStatus::Verified);
-
-    events::emit_status_change(env, expert.clone(), current_status, ExpertStatus::Verified, admin);
-
+
+    events::emit_status_change(
+        env,
+        expert.clone(),
+        current_status,
+        ExpertStatus::Verified,
+        admin,
+    );
+
     Ok(())
-}
+}
+
+/// Ban an expert by setting their status to Banned (Admin only)
+pub fn ban_expert(env: &Env, expert: &Address) -> Result<(), RegistryError> {
+    let admin = storage::get_admin(env).ok_or(RegistryError::NotInitialized)?;
+    admin.require_auth();
+
+    let current_status = storage::get_expert_status(env, expert);
+
+    if current_status == ExpertStatus::Banned {
+        return Err(RegistryError::AlreadyBanned);
+    }
+
+    storage::set_expert_record(env, expert, ExpertStatus::Banned);
+
+    events::emit_status_change(
+        env,
+        expert.clone(),
+        current_status,
+        ExpertStatus::Banned,
+        admin,
+    );
+
+    Ok(())
+}
+
+/// Get the current status of an expert
+pub fn get_expert_status(env: &Env, expert: &Address) -> ExpertStatus {
+    storage::get_expert_status(env, expert)
+}

contracts/identity-registry-contract/src/error.rs

@@ -16,4 +16,4 @@ pub enum RegistryError {
     AlreadyVerified = 5,
     AlreadyBanned = 6,
     ExpertVecMax = 7,
-}
+}

contracts/identity-registry-contract/src/events.rs

@@ -1,5 +1,5 @@
-use soroban_sdk::{contracttype, Address, Env, Symbol};
 use crate::types::ExpertStatus;
+use soroban_sdk::{contracttype, Address, Env, Symbol};
 
 // The Event Data Structure
 #[contracttype]
@@ -11,21 +11,22 @@ pub struct ExpertStatusChangedEvent {
     pub admin: Address,
 }
 
-// Helper function to emit the event
+// Helper function to emit the status change event
 pub fn emit_status_change(
-    env: &Env, 
-    expert: Address, 
-    old_status: ExpertStatus, 
-    new_status: ExpertStatus, 
-    admin: Address
+    env: &Env,
+    expert: Address,
+    old_status: ExpertStatus,
+    new_status: ExpertStatus,
+    admin: Address,
 ) {
     let event = ExpertStatusChangedEvent {
         expert,
         old_status,
         new_status,
         admin,
     };
-    
+
     // We publish with the topic "status_change" so indexers can find it easily
-    env.events().publish((Symbol::new(env, "status_change"),), event);
-}
+    env.events()
+        .publish((Symbol::new(env, "status_change"),), event);
+}

contracts/identity-registry-contract/src/lib.rs

@@ -4,12 +4,13 @@ mod contract;
 mod error;
 mod events;
 mod storage;
-mod types;
 #[cfg(test)]
 mod test;
+mod types;
 
-use soroban_sdk::{contract, contractimpl, Address, Env, Vec};
-use crate::{error::RegistryError};
+use crate::error::RegistryError;
+use crate::types::ExpertStatus;
+use soroban_sdk::{contract, contractimpl, Address, Env,Vec};
 
 #[contract]
 pub struct IdentityRegistryContract;
@@ -30,4 +31,14 @@ impl IdentityRegistryContract {
     pub fn add_expert(env: Env, expert: Address) -> Result<(), RegistryError> {
         contract::verify_expert(&env, &expert)
     }
+
+    /// Ban an expert and revoke their verification status (Admin only)
+    pub fn ban_expert(env: Env, expert: Address) -> Result<(), RegistryError> {
+        contract::ban_expert(&env, &expert)
+    }
+
+    /// Get the current status of an expert
+    pub fn get_status(env: Env, expert: Address) -> ExpertStatus {
+        contract::get_expert_status(&env, &expert)
+    }
 }

contracts/identity-registry-contract/src/storage.rs

@@ -1,12 +1,12 @@
+use crate::types::{ExpertRecord, ExpertStatus};
 use soroban_sdk::{contracttype, Address, Env};
-use crate::types::{ExpertStatus, ExpertRecord};
 
 // 1. Data Keys
 #[contracttype]
 #[derive(Clone)]
 pub enum DataKey {
-    Admin,              
-    Expert(Address),    
+    Admin,
+    Expert(Address),
 }
 
 // Constants for TTL (Time To Live)
@@ -23,23 +23,27 @@ const LEDGERS_EXTEND_TO: u32 = 6_300_000; // ~1 year
 
 // ... [Admin Helpers] ...
 
+/// Check if the admin has been set
 pub fn has_admin(env: &Env) -> bool {
     env.storage().instance().has(&DataKey::Admin)
 }
 
+/// Set the admin address
 pub fn set_admin(env: &Env, admin: &Address) {
     env.storage().instance().set(&DataKey::Admin, admin);
 }
 
+/// Get the admin address
 pub fn get_admin(env: &Env) -> Option<Address> {
     env.storage().instance().get(&DataKey::Admin)
 }
 
 // ... [Expert Helpers] ...
 
+/// Set the expert record with status and timestamp
 pub fn set_expert_record(env: &Env, expert: &Address, status: ExpertStatus) {
     let key = DataKey::Expert(expert.clone());
-    
+
     let record = ExpertRecord {
         status,
         updated_at: env.ledger().timestamp(),
@@ -49,26 +53,23 @@ pub fn set_expert_record(env: &Env, expert: &Address, status: ExpertStatus) {
     env.storage().persistent().set(&key, &record);
 
     // 2. Extend the TTL
-    // This tells the network: "If this data is going to die in less than 2 months, 
+    // This tells the network: "If this data is going to die in less than 2 months,
     // extend its life to 1 full year from now."
-    env.storage().persistent().extend_ttl(
-        &key, 
-        LEDGERS_THRESHOLD, 
-        LEDGERS_EXTEND_TO
-    );
+    env.storage()
+        .persistent()
+        .extend_ttl(&key, LEDGERS_THRESHOLD, LEDGERS_EXTEND_TO);
 }
 
+/// Get the expert record, extending TTL if exists
 pub fn get_expert_record(env: &Env, expert: &Address) -> ExpertRecord {
     let key = DataKey::Expert(expert.clone());
-    
+
     // We also bump TTL on reads
     // If an expert is being checked frequently, they should stay alive.
     if env.storage().persistent().has(&key) {
-        env.storage().persistent().extend_ttl(
-            &key, 
-            LEDGERS_THRESHOLD, 
-            LEDGERS_EXTEND_TO
-        );
+        env.storage()
+            .persistent()
+            .extend_ttl(&key, LEDGERS_THRESHOLD, LEDGERS_EXTEND_TO);
     }
 
     env.storage()
@@ -80,6 +81,7 @@ pub fn get_expert_record(env: &Env, expert: &Address) -> ExpertRecord {
         })
 }
 
+/// Get the expert status
 pub fn get_expert_status(env: &Env, expert: &Address) -> ExpertStatus {
     get_expert_record(env, expert).status
-}
+}