bad rebase fixed

Author: ZocoLini

dash-spv/peer_reputation.json

@@ -41,8 +41,7 @@ impl<W: WalletInterface, N: NetworkManager, S: StorageManager> DashSpvClient<W,
                 .await
             {
                 // Penalize the peer that relayed the invalid ChainLock
-                let reason = format!("Invalid ChainLock: {}", e);
-                self.network.penalize_peer_invalid_chainlock(peer_address, &reason).await;
+                self.network.penalize_peer_invalid_chainlock(peer_address).await;
                 return Err(SpvError::Validation(e));
             }
         }
@@ -110,7 +109,7 @@ impl<W: WalletInterface, N: NetworkManager, S: StorageManager> DashSpvClient<W,
             tracing::warn!("{}", reason);
 
             // Ban the peer using the reputation system
-            self.network.penalize_peer_invalid_instantlock(peer_address, &reason).await;
+            self.network.penalize_peer_invalid_instantlock(peer_address).await;
 
             return Err(SpvError::Validation(e));
         }

dash-spv/src/client/chainlock.rs

@@ -32,6 +32,20 @@ impl<W: WalletInterface, N: NetworkManager, S: StorageManager> DashSpvClient<W,
         self.network.peer_count()
     }
 
+    /// Disconnect a specific peer.
+    pub async fn disconnect_peer(&self, addr: &std::net::SocketAddr, reason: &str) -> Result<()> {
+        // Cast network manager to PeerNetworkManager to access disconnect_peer
+        let network = self
+            .network
+            .as_any()
+            .downcast_ref::<crate::network::manager::PeerNetworkManager>()
+            .ok_or_else(|| {
+                SpvError::Config("Network manager does not support peer disconnection".to_string())
+            })?;
+
+        network.disconnect_peer(addr, reason).await
+    }
+
     // ============ Masternode Queries ============
 
     /// Get a reference to the masternode list engine.

dash-spv/src/client/queries.rs

@@ -1,6 +1,6 @@
 //! Peer network manager for SPV client
 
-use std::collections::HashSet;
+use std::collections::{HashMap, HashSet};
 use std::net::SocketAddr;
 use std::path::PathBuf;
 use std::sync::atomic::{AtomicUsize, Ordering};
@@ -17,9 +17,7 @@ use crate::network::addrv2::AddrV2Handler;
 use crate::network::constants::*;
 use crate::network::discovery::DnsDiscovery;
 use crate::network::pool::PeerPool;
-use crate::network::reputation::{
-    misbehavior_scores, positive_scores, PeerReputationManager, ReputationAware,
-};
+use crate::network::reputation::{ChangeReason, PeerReputationManager};
 use crate::network::{
     HandshakeManager, Message, MessageDispatcher, MessageType, NetworkManager, Peer,
 };
@@ -446,11 +444,9 @@ impl PeerNetworkManager {
                                         headers2_disabled.lock().await.insert(addr);
                                         // Apply reputation penalty
                                         reputation_manager
-                                            .update_reputation(
-                                                addr,
-                                                misbehavior_scores::INVALID_MESSAGE,
-                                                "Headers2 decompression failed",
-                                            )
+                                            .lock()
+                                            .await
+                                            .update_reputation(addr, ChangeReason::InvalidHeaders2)
                                             .await;
                                         continue; // Don't forward corrupted message
                                     }
@@ -759,7 +755,7 @@ impl PeerNetworkManager {
                     }
 
                     // Save reputation data periodically
-                    if let Err(e) = reputation_manager.save_to_storage(&*peer_store).await {
+                    if let Err(e) = reputation_manager.lock().await.save_to_storage(&*peer_store).await {
                         log::warn!("Failed to save reputation data: {}", e);
                     }
                 }
@@ -972,16 +968,37 @@ impl PeerNetworkManager {
     }
 
     /// Disconnect a specific peer
-    pub async fn disconnect_peer(&self, addr: &SocketAddr) -> Result<(), Error> {
+    pub async fn disconnect_peer(&self, addr: &SocketAddr, reason: &str) -> Result<(), Error> {
+        log::info!("Disconnecting peer {} - reason: {}", addr, reason);
+
+        // Remove the peer
         self.pool.remove_peer(addr).await;
 
         Ok(())
     }
 
     /// Get reputation information for all peers
     pub async fn get_peer_reputations(&self) -> HashMap<SocketAddr, (i32, bool)> {
-        let reputations = self.reputation_manager.lock().await.get_all_reputations().await;
-        reputations.into_iter().map(|(addr, rep)| (addr, (rep.score, rep.is_banned()))).collect()
+        let mut lock = self.reputation_manager.lock().await;
+        let reputations = lock.get_all_reputations().await;
+        reputations.iter().map(|(addr, rep)| (*addr, (rep.score(), rep.is_banned()))).collect()
+    }
+
+    /// Ban a specific peer manually
+    pub async fn ban_peer(&self, addr: &SocketAddr, reason: &str) -> Result<(), Error> {
+        log::info!("Manually banning peer {} - reason: {}", addr, reason);
+
+        // Disconnect the peer first
+        self.disconnect_peer(addr, reason).await?;
+
+        // Update reputation to trigger ban
+        self.reputation_manager
+            .lock()
+            .await
+            .update_reputation(*addr, ChangeReason::ManuallyBanned)
+            .await;
+
+        Ok(())
     }
 
     /// Unban a specific peer
@@ -1003,7 +1020,9 @@ impl PeerNetworkManager {
         }
 
         // Save reputation data before shutdown
-        if let Err(e) = self.reputation_manager.save_to_storage(&*self.peer_store).await {
+        if let Err(e) =
+            self.reputation_manager.lock().await.save_to_storage(&*self.peer_store).await
+        {
             log::warn!("Failed to save reputation data on shutdown: {}", e);
         }
 
@@ -1098,64 +1117,62 @@ impl NetworkManager for PeerNetworkManager {
         } // end match
     } // end send_message
 
-    async fn penalize_peer(&self, address: SocketAddr, score_change: i32, reason: &str) {
-        self.reputation_manager.update_reputation(address, score_change, reason).await;
+    async fn penalize_peer(&self, address: SocketAddr, reason: ChangeReason) {
+        self.reputation_manager.lock().await.update_reputation(address, reason).await;
     }
 
-    async fn penalize_peer_invalid_chainlock(&self, address: SocketAddr, reason: &str) {
-        match self.disconnect_peer(&address, reason).await {
+    async fn penalize_peer_invalid_chainlock(&self, address: SocketAddr) {
+        match self.disconnect_peer(&address, &ChangeReason::InvalidChainLock.to_string()).await {
             Ok(()) => {
-                log::warn!(
-                    "Peer {} disconnected for invalid ChainLock enforcement: {}",
-                    address,
-                    reason
-                );
+                log::warn!("Peer {} disconnected for invalid ChainLock enforcement", address,);
             }
             Err(err) => {
                 log::error!(
-                    "Failed to disconnect peer {} after invalid ChainLock enforcement ({}): {}",
+                    "Failed to disconnect peer {} after invalid ChainLock enforcement: {}",
                     address,
-                    reason,
                     err
                 );
             }
         }
 
         // Apply misbehavior score and a short temporary ban
         self.reputation_manager
-            .update_reputation(address, misbehavior_scores::INVALID_CHAINLOCK, reason)
+            .lock()
+            .await
+            .update_reputation(address, ChangeReason::InvalidChainLock)
             .await;
 
         // Short ban: 10 minutes for relaying invalid ChainLock
         self.reputation_manager
-            .temporary_ban_peer(address, Duration::from_secs(10 * 60), reason)
+            .lock()
+            .await
+            .temporary_ban_peer(address, Duration::from_secs(10 * 60))
             .await;
     }
 
-    async fn penalize_peer_invalid_instantlock(&self, address: SocketAddr, reason: &str) {
+    async fn penalize_peer_invalid_instantlock(&self, address: SocketAddr) {
         // Apply misbehavior score and a short temporary ban
         self.reputation_manager
-            .update_reputation(address, misbehavior_scores::INVALID_INSTANTLOCK, reason)
+            .lock()
+            .await
+            .update_reputation(address, ChangeReason::InvalidInstantLock)
             .await;
 
         // Short ban: 10 minutes for relaying invalid InstantLock
         self.reputation_manager
-            .temporary_ban_peer(address, Duration::from_secs(10 * 60), reason)
+            .lock()
+            .await
+            .temporary_ban_peer(address, Duration::from_secs(10 * 60))
             .await;
 
-        match self.disconnect_peer(&address, reason).await {
+        match self.disconnect_peer(&address, &ChangeReason::InvalidInstantLock.to_string()).await {
             Ok(()) => {
-                log::warn!(
-                    "Peer {} disconnected for invalid InstantLock enforcement: {}",
-                    address,
-                    reason
-                );
+                log::warn!("Peer {} disconnected for invalid InstantLock enforcement", address,);
             }
             Err(err) => {
                 log::error!(
-                    "Failed to disconnect peer {} after invalid InstantLock enforcement ({}): {}",
+                    "Failed to disconnect peer {} after invalid InstantLock enforcement: {}",
                     address,
-                    reason,
                     err
                 );
             }

dash-spv/src/network/manager.rs

@@ -14,7 +14,7 @@ mod message_type;
 #[cfg(test)]
 mod tests;
 
-use crate::error::NetworkResult;
+use crate::{error::NetworkResult, network::reputation::ChangeReason};
 use async_trait::async_trait;
 use dashcore::network::message::NetworkMessage;
 use dashcore::BlockHash;
@@ -23,6 +23,7 @@ pub use manager::PeerNetworkManager;
 pub use message_dispatcher::{Message, MessageDispatcher};
 pub use message_type::MessageType;
 pub use peer::Peer;
+pub(crate) use reputation::PeerReputation;
 use std::net::SocketAddr;
 use tokio::sync::mpsc::UnboundedReceiver;
 
@@ -95,25 +96,15 @@ pub trait NetworkManager: Send + Sync + 'static {
 
     /// Penalize a peer by address by adjusting reputation.
     /// Default implementation is a no-op for managers without reputation.
-    async fn penalize_peer(&self, _address: SocketAddr, _score_change: i32, _reason: &str) {}
+    async fn penalize_peer(&self, _address: SocketAddr, _reason: ChangeReason) {}
 
     /// Penalize a peer by address for an invalid ChainLock.
-    async fn penalize_peer_invalid_chainlock(&self, address: SocketAddr, reason: &str) {
-        self.penalize_peer(
-            address,
-            crate::network::reputation::misbehavior_scores::INVALID_CHAINLOCK,
-            reason,
-        )
-        .await;
+    async fn penalize_peer_invalid_chainlock(&self, address: SocketAddr) {
+        self.penalize_peer(address, ChangeReason::InvalidChainLock).await;
     }
 
     /// Penalize a peer by address for an invalid InstantLock.
-    async fn penalize_peer_invalid_instantlock(&self, peer_address: SocketAddr, reason: &str) {
-        self.penalize_peer(
-            peer_address,
-            crate::network::reputation::misbehavior_scores::INVALID_INSTANTLOCK,
-            reason,
-        )
-        .await;
+    async fn penalize_peer_invalid_instantlock(&self, peer_address: SocketAddr) {
+        self.penalize_peer(peer_address, ChangeReason::InvalidInstantLock).await;
     }
 }