bad rebase fixed

ZocoLini · ZocoLini · commit fe8384ed3408 · 2026-01-26T19:58:02.000Z
diff --git a/dash-spv/src/client/chainlock.rs b/dash-spv/src/client/chainlock.rs
@@ -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));
         }
diff --git a/dash-spv/src/network/manager.rs b/dash-spv/src/network/manager.rs
@@ -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);
                     }
                 }
@@ -978,17 +974,6 @@ impl PeerNetworkManager {
         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()
-    }
-
-    /// Unban a specific peer
-    pub async fn unban_peer(&self, addr: &SocketAddr) {
-        self.reputation_manager.lock().await.unban_peer(addr).await;
-    }
-
     /// Shutdown the network manager
     pub async fn shutdown(&self) {
         log::info!("Shutting down peer network manager");
@@ -1003,7 +988,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 +1085,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).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).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
                 );
             }
diff --git a/dash-spv/src/network/mod.rs b/dash-spv/src/network/mod.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;
     }
 }
diff --git a/dash-spv/src/network/reputation.rs b/dash-spv/src/network/reputation.rs
@@ -80,8 +80,6 @@ const MIN_MISBEHAVIOR_SCORE: i32 = -50;
 
 const MAX_BAN_COUNT: u32 = 1000;
 
-const MAX_ACTION_COUNT: u64 = 1_000_000;
-
 fn clamp_peer_score<'de, D>(deserializer: D) -> Result<i32, D::Error>
 where
     D: Deserializer<'de>,
@@ -113,52 +111,10 @@ where
     Ok(v)
 }
 
-fn clamp_peer_connection_attempts<'de, D>(deserializer: D) -> Result<u64, D::Error>
-where
-    D: Deserializer<'de>,
-{
-    let mut v = u64::deserialize(deserializer)?;
-
-    v = v.min(MAX_ACTION_COUNT);
-
-    Ok(v)
-}
-
 fn default_instant() -> Instant {
     Instant::now()
 }
 
-fn clamp_peer_score<'de, D>(deserializer: D) -> Result<i32, D::Error>
-where
-    D: Deserializer<'de>,
-{
-    let mut v = i32::deserialize(deserializer)?;
-
-    if v < MIN_MISBEHAVIOR_SCORE {
-        log::warn!("Peer has invalid score {v}, clamping to min {MIN_MISBEHAVIOR_SCORE}");
-        v = MIN_MISBEHAVIOR_SCORE
-    } else if v > MAX_MISBEHAVIOR_SCORE {
-        log::warn!("Peer has invalid score {v}, clamping to max {MAX_MISBEHAVIOR_SCORE}");
-        v = MAX_MISBEHAVIOR_SCORE
-    }
-
-    Ok(v)
-}
-
-fn clamp_peer_ban_count<'de, D>(deserializer: D) -> Result<u32, D::Error>
-where
-    D: Deserializer<'de>,
-{
-    let mut v = u32::deserialize(deserializer)?;
-
-    if v > MAX_BAN_COUNT {
-        log::warn!("Peer has excessive ban count {v}, clamping to {MAX_BAN_COUNT}");
-        v = MAX_BAN_COUNT
-    }
-
-    Ok(v)
-}
-
 /// Peer reputation entry
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct PeerReputation {
@@ -239,7 +195,7 @@ pub struct PeerReputationManager {
 }
 
 impl PeerReputationManager {
-    pub async fn load_or_new(storage: &PersistentPeerStorage) -> Self {
+    pub async fn load_or_new(storage: &impl PeerStorage) -> Self {
         let mut reputations =
             storage.load_peers_reputation().await.unwrap_or_else(|_| HashMap::new());
 
@@ -332,16 +288,6 @@ impl PeerReputationManager {
         reputation.last_connection = Some(Instant::now());
     }
 
-    /// Clear banned status for a peer (admin function)
-    pub async fn unban_peer(&mut self, peer: &SocketAddr) {
-        let reputations = &mut self.reputations;
-        if let Some(reputation) = reputations.get_mut(peer) {
-            reputation.banned_until = None;
-            reputation.score = reputation.score.min(MAX_MISBEHAVIOR_SCORE - 10);
-            log::info!("Manually unbanned peer {}", peer);
-        }
-    }
-
     pub async fn select_best_peers(
         &mut self,
         available_peers: Vec<SocketAddr>,
@@ -372,34 +318,13 @@ impl PeerReputationManager {
 
     /// Save reputation data to persistent storage
     pub async fn save_to_storage(&self, storage: &impl PeerStorage) -> std::io::Result<()> {
-        let reputations = self.reputations.read().await;
-
-        storage.save_peers_reputation(&reputations).await.map_err(std::io::Error::other)
-    }
-
-    /// Load reputation data from persistent storage
-    pub async fn load_from_storage(&self, storage: &impl PeerStorage) -> std::io::Result<()> {
-        let data = storage.load_peers_reputation().await.map_err(std::io::Error::other)?;
-        log::info!("Loaded reputation data for {} peers", data.len());
-
-        let reputations = &mut self.reputations;
-
-        for (addr, mut reputation) in data {
-            // Apply initial decay based on ban count
-            if reputation.ban_count > 0 {
-                reputation.score = reputation.score.max(50); // Start with higher score for previously banned peers
-            }
-
-            reputations.insert(addr, reputation);
-        }
-
-        Ok(())
+        storage.save_peers_reputation(&self.reputations).await.map_err(std::io::Error::other)
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::storage::PersistentStorage;
+    use crate::storage::{PersistentPeerStorage, PersistentStorage};
 
     use super::*;
     use std::net::SocketAddr;
diff --git a/dash-spv/src/storage/mod.rs b/dash-spv/src/storage/mod.rs
@@ -87,7 +87,6 @@ pub struct DiskStorageManager {
     metadata: Arc<RwLock<PersistentMetadataStorage>>,
     chainstate: Arc<RwLock<PersistentChainStateStorage>>,
     masternodestate: Arc<RwLock<PersistentMasternodeStateStorage>>,
-    peers: Arc<RwLock<PersistentPeerStorage>>,
 
     // Background worker
     worker_handle: Option<tokio::task::JoinHandle<()>>,
@@ -130,7 +129,6 @@ impl DiskStorageManager {
             masternodestate: Arc::new(RwLock::new(
                 PersistentMasternodeStateStorage::open(&storage_path).await?,
             )),
-            peers: Arc::new(RwLock::new(PersistentPeerStorage::open(&storage_path).await?)),
 
             worker_handle: None,
 
diff --git a/dash-spv/src/storage/peers.rs b/dash-spv/src/storage/peers.rs
@@ -97,27 +97,25 @@ impl PeerStorage for PersistentPeerStorage {
             return Ok(Vec::new());
         };
 
-        let mut peers = Vec::new();
-
         let peers = tokio::task::spawn_blocking(move || {
             let file = File::open(&peers_file)?;
             let mut reader = BufReader::new(file);
 
-        let file = File::open(&peers_file)?;
-        let mut reader = BufReader::new(file);
-        let mut peers = Vec::new();
-
-        loop {
-            match AddrV2Message::consensus_decode(&mut reader) {
-                Ok(peer) => peers.push(peer),
-                Err(encode::Error::Io(ref e)) if e.kind() == std::io::ErrorKind::UnexpectedEof => {
-                    break
-                }
-                Err(e) => {
-                    return Err(StorageError::ReadFailed(format!("Failed to decode peer: {e}")))
+            let mut peers = Vec::new();
+
+            loop {
+                match AddrV2Message::consensus_decode(&mut reader) {
+                    Ok(peer) => peers.push(peer),
+                    Err(encode::Error::Io(ref e))
+                        if e.kind() == std::io::ErrorKind::UnexpectedEof =>
+                    {
+                        break
+                    }
+                    Err(e) => {
+                        return Err(StorageError::ReadFailed(format!("Failed to decode peer: {e}")))
+                    }
                 }
             }
-
             Ok(peers)
         })
         .await
diff --git a/dash-spv/tests/peer_test.rs b/dash-spv/tests/peer_test.rs

Original file line number	Diff line number	Diff line change
`@@ -41,8 +41,7 @@ impl<W: WalletInterface, N: NetworkManager, S: StorageManager> DashSpvClient<W,`
`41`	`41`	`.await`
`42`	`42`	`{`
`43`	`43`	`// Penalize the peer that relayed the invalid ChainLock`
`44`		`- let reason = format!("Invalid ChainLock: {}", e);`
`45`		`- self.network.penalize_peer_invalid_chainlock(peer_address, &reason).await;`
	`44`	`+ self.network.penalize_peer_invalid_chainlock(peer_address).await;`
`46`	`45`	`return Err(SpvError::Validation(e));`
`47`	`46`	`}`
`48`	`47`	`}`
`@@ -110,7 +109,7 @@ impl<W: WalletInterface, N: NetworkManager, S: StorageManager> DashSpvClient<W,`
`110`	`109`	`tracing::warn!("{}", reason);`
`111`	`110`
`112`	`111`	`// Ban the peer using the reputation system`
`113`		`- self.network.penalize_peer_invalid_instantlock(peer_address, &reason).await;`
	`112`	`+ self.network.penalize_peer_invalid_instantlock(peer_address).await;`
`114`	`113`
`115`	`114`	`return Err(SpvError::Validation(e));`
`116`	`115`	`}`