From a3e500db12191ce3cd96190116202eabc8ecb626 Mon Sep 17 00:00:00 2001
From: Mykhailo Kremniov <mkremniov@gmail.com>
Date: Wed, 24 Jan 2024 10:50:17 +0200
Subject: [PATCH] Discouraged peers are now disconnected automatically; Peers
 are no longer automatically banned; Ban duration is now always specified
 explicitly by the user; Time formatting improvements; Wallet & rpc commands
 for printing reserved and discouraged addresses were added; Printing banned
 and discouraged addresses now also prints the expiration time;

---
 Cargo.lock                                    |   8 +
 Cargo.toml                                    |   1 +
 chainstate/src/detail/mod.rs                  |   2 +-
 common/src/chain/transaction/printout.rs      |   5 +-
 common/src/primitives/time.rs                 |  67 +++++-
 dns-server/src/main.rs                        |   4 +-
 node-lib/src/config_files/mod.rs              |   8 +-
 node-lib/src/config_files/p2p.rs              |   8 -
 node-lib/src/options.rs                       |  10 +-
 node-lib/tests/cli.rs                         |  23 +-
 p2p/benches/benches.rs                        |   7 +-
 p2p/src/ban_config.rs                         |  25 +-
 p2p/src/error.rs                              |   9 -
 p2p/src/interface/p2p_interface.rs            |  11 +-
 p2p/src/interface/p2p_interface_impl.rs       |  30 ++-
 .../p2p_interface_impl_delegation.rs          |  21 +-
 p2p/src/peer_manager/config.rs                |   2 +-
 p2p/src/peer_manager/mod.rs                   |  81 ++++---
 p2p/src/peer_manager/peerdb/mod.rs            |  28 ++-
 p2p/src/peer_manager/peerdb/tests.rs          | 214 +++++++++++++++++-
 p2p/src/peer_manager/peers_eviction/mod.rs    |   4 +
 p2p/src/peer_manager/tests/ban.rs             |  88 +++----
 p2p/src/peer_manager/tests/discouragement.rs  | 159 ++++++++++++-
 p2p/src/peer_manager/tests/utils.rs           |  20 +-
 p2p/src/peer_manager/tests/whitelist.rs       |   6 +-
 p2p/src/peer_manager_event.rs                 |  18 +-
 p2p/src/rpc.rs                                |  33 ++-
 p2p/src/sync/peer_v2/block_manager.rs         |   4 +-
 p2p/src/sync/tests/block_response.rs          |   7 +-
 p2p/src/sync/tests/helpers/mod.rs             |  14 +-
 p2p/src/sync/tests/helpers/test_node_group.rs |   4 +-
 p2p/src/tests/correct_handshake.rs            |   4 +-
 p2p/src/tests/helpers/test_node.rs            |   5 +-
 p2p/src/tests/incorrect_handshake.rs          |  19 +-
 wallet/src/wallet/mod.rs                      |   2 +-
 wallet/wallet-cli-lib/Cargo.toml              |   2 +
 .../src/commands/helper_types.rs              |  17 ++
 wallet/wallet-cli-lib/src/commands/mod.rs     |  52 ++++-
 .../wallet-controller/src/sync/tests/mod.rs   |  21 +-
 .../src/handles_client/mod.rs                 |  32 ++-
 wallet/wallet-node-client/src/node_traits.rs  |  19 +-
 .../src/rpc_client/client_impl.rs             |  29 ++-
 .../src/rpc_client/cold_wallet_client.rs      |  25 +-
 wallet/wallet-rpc-lib/src/rpc/interface.rs    |  20 +-
 wallet/wallet-rpc-lib/src/rpc/mod.rs          |  26 ++-
 wallet/wallet-rpc-lib/src/rpc/server_impl.rs  |  25 +-
 46 files changed, 915 insertions(+), 304 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 0dd4ad8d58..879254118a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2714,6 +2714,12 @@ version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
 
+[[package]]
+name = "humantime"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
+
 [[package]]
 name = "hyper"
 version = "0.14.28"
@@ -7517,6 +7523,8 @@ dependencies = [
  "directories",
  "futures",
  "hex",
+ "humantime",
+ "itertools 0.12.0",
  "logging",
  "mempool",
  "node-comm",
diff --git a/Cargo.toml b/Cargo.toml
index 3251bc066c..2d8d42eafb 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -139,6 +139,7 @@ criterion = "0.5"
 crossterm = "0.27"
 derive_more = "0.99"
 directories = "5.0"
+humantime = "2.1"
 dyn-clone = "1.0"
 enum-iterator = "1.4"
 expect-test = "1.3"
diff --git a/chainstate/src/detail/mod.rs b/chainstate/src/detail/mod.rs
index 261af811f2..eb396a3368 100644
--- a/chainstate/src/detail/mod.rs
+++ b/chainstate/src/detail/mod.rs
@@ -537,7 +537,7 @@ impl<S: BlockchainStorage, V: TransactionVerificationStrategy> Chainstate<S, V>
                 bi.block_id(),
                 bi.block_height(),
                 bi.block_timestamp(),
-                bi.block_timestamp().into_time().as_standard_printable_time(),
+                bi.block_timestamp().into_time(),
             );
 
             self.update_initial_block_download_flag()
diff --git a/common/src/chain/transaction/printout.rs b/common/src/chain/transaction/printout.rs
index 2eb3e52272..96b04751cf 100644
--- a/common/src/chain/transaction/printout.rs
+++ b/common/src/chain/transaction/printout.rs
@@ -61,10 +61,7 @@ pub fn transaction_summary(tx: &Transaction, chain_config: &ChainConfig) -> Stri
     };
     let fmt_timelock = |tl: &OutputTimeLock| match tl {
         OutputTimeLock::UntilHeight(h) => format!("OutputTimeLock::UntilHeight({h})"),
-        OutputTimeLock::UntilTime(t) => format!(
-            "OutputTimeLock::UntilTime({})",
-            t.into_time().as_standard_printable_time()
-        ),
+        OutputTimeLock::UntilTime(t) => format!("OutputTimeLock::UntilTime({})", t.into_time()),
         OutputTimeLock::ForBlockCount(n) => format!("OutputTimeLock::ForBlockCount({n} blocks)"),
         OutputTimeLock::ForSeconds(secs) => {
             format!("OutputTimeLock::ForSeconds({secs} seconds)")
diff --git a/common/src/primitives/time.rs b/common/src/primitives/time.rs
index 34d268271f..1d87a891ba 100644
--- a/common/src/primitives/time.rs
+++ b/common/src/primitives/time.rs
@@ -13,9 +13,13 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use std::fmt::{Debug, Display};
 use std::sync::atomic::{AtomicU64, Ordering};
 use std::time::{Duration, SystemTime};
 
+use chrono::TimeZone;
+use serde::{Deserialize, Serialize};
+
 pub fn duration_to_int(d: &Duration) -> Result<u64, std::num::TryFromIntError> {
     let r = d.as_millis().try_into()?;
     Ok(r)
@@ -61,7 +65,7 @@ pub fn get_time() -> Time {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
 pub struct Time {
     /// Time, stored as duration since SystemTime::UNIX_EPOCH
     time: Duration,
@@ -102,13 +106,13 @@ impl Time {
         self.time.saturating_sub(t.time)
     }
 
-    pub fn as_absolute_time(&self) -> SystemTime {
-        SystemTime::UNIX_EPOCH + self.time
-    }
-
-    pub fn as_standard_printable_time(&self) -> String {
-        let datetime: chrono::DateTime<chrono::Utc> = self.as_absolute_time().into();
-        format!("{}", datetime.format("%Y-%m-%d %H:%M:%S"))
+    pub fn as_absolute_time(&self) -> Option<chrono::DateTime<chrono::Utc>> {
+        TryInto::<i64>::try_into(self.time.as_secs()).ok().and_then(|secs| {
+            // Note: chrono::DateTime supports time values up to about 262,000 years away
+            // from the common era, which is still way below i64::MAX; i.e. timestamp_opt
+            // may still return None here.
+            chrono::Utc.timestamp_opt(secs, self.time.subsec_nanos()).single()
+        })
     }
 }
 
@@ -136,6 +140,33 @@ impl std::ops::Sub<Time> for Time {
     }
 }
 
+impl Debug for Time {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let utc_time = self.as_absolute_time();
+
+        if let Some(time) = utc_time {
+            write!(f, "{time:?}")
+        } else {
+            write!(f, "Time({:?})", self.time)
+        }
+    }
+}
+
+impl Display for Time {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let utc_time = self.as_absolute_time();
+
+        if let Some(time) = utc_time {
+            write!(f, "{time}")
+        } else {
+            // Note: we could use humantime::format_duration here, but the output won't be
+            // very nice, e.g. for Duration::MAX it'll be:
+            // "584542046090years 7months 15days 17h 5m 3s 999ms 999us 999ns"
+            write!(f, "{:?} since Unix epoch", self.time)
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use logging::log;
@@ -189,9 +220,23 @@ mod tests {
     }
 
     #[test]
-    fn format_absolute_time() {
+    fn debug_display() {
         let t = Time::from_secs_since_epoch(1705064092);
-        let s = t.as_standard_printable_time().to_string();
-        assert_eq!(&s, "2024-01-12 12:54:52");
+        let s = format!("{t:?}");
+        assert_eq!(s, "2024-01-12T12:54:52Z");
+        let s = format!("{t}");
+        assert_eq!(s, "2024-01-12 12:54:52 UTC");
+
+        let t = Time::from_duration_since_epoch(Duration::from_millis(1705064092123));
+        let s = format!("{t:?}");
+        assert_eq!(s, "2024-01-12T12:54:52.123Z");
+        let s = format!("{t}");
+        assert_eq!(s, "2024-01-12 12:54:52.123 UTC");
+
+        let t = Time::from_duration_since_epoch(Duration::MAX);
+        let s = format!("{t:?}");
+        assert_eq!(s, "Time(18446744073709551615.999999999s)");
+        let s = format!("{t}");
+        assert_eq!(s, "18446744073709551615.999999999s since Unix epoch");
     }
 }
diff --git a/dns-server/src/main.rs b/dns-server/src/main.rs
index 03a55ed30f..22a1df7f5a 100644
--- a/dns-server/src/main.rs
+++ b/dns-server/src/main.rs
@@ -58,8 +58,8 @@ async fn run(config: Arc<DnsServerConfig>) -> Result<Never, error::DnsServerErro
         boot_nodes: Vec::new(),
         reserved_nodes: Vec::new(),
         whitelisted_addresses: Default::default(),
-        // Note: this ban config (as well as any other non-backend setting here) won't have
-        // any effect on the dns server.
+        // Note: this ban config (as well as any other settings related to the peer or sync manager)
+        // won't have any effect on the dns server.
         ban_config: Default::default(),
         outbound_connection_timeout: Default::default(),
         ping_check_period: Default::default(),
diff --git a/node-lib/src/config_files/mod.rs b/node-lib/src/config_files/mod.rs
index 2ea40329a9..cad18b8f90 100644
--- a/node-lib/src/config_files/mod.rs
+++ b/node-lib/src/config_files/mod.rs
@@ -172,8 +172,6 @@ fn p2p_config(config: P2pConfigFile, options: &RunOptions) -> P2pConfigFile {
         reserved_nodes,
         whitelisted_addresses,
         max_inbound_connections,
-        ban_threshold,
-        ban_duration,
         discouragement_threshold,
         discouragement_duration,
         max_clock_diff,
@@ -192,7 +190,9 @@ fn p2p_config(config: P2pConfigFile, options: &RunOptions) -> P2pConfigFile {
     let reserved_nodes = options.p2p_reserved_node.clone().or(reserved_nodes);
     let whitelisted_addresses = options.p2p_whitelist_addr.clone().or(whitelisted_addresses);
     let max_inbound_connections = options.p2p_max_inbound_connections.or(max_inbound_connections);
-    let ban_threshold = options.p2p_ban_threshold.or(ban_threshold);
+    let discouragement_threshold =
+        options.p2p_discouragement_threshold.or(discouragement_threshold);
+    let discouragement_duration = options.p2p_discouragement_duration.or(discouragement_duration);
     let ping_check_period = options.p2p_ping_check_period.or(ping_check_period);
     let ping_timeout = options.p2p_ping_timeout.or(ping_timeout);
     let max_clock_diff = options.p2p_max_clock_diff.or(max_clock_diff);
@@ -212,8 +212,6 @@ fn p2p_config(config: P2pConfigFile, options: &RunOptions) -> P2pConfigFile {
         reserved_nodes,
         whitelisted_addresses,
         max_inbound_connections,
-        ban_threshold,
-        ban_duration,
         discouragement_threshold,
         discouragement_duration,
         max_clock_diff,
diff --git a/node-lib/src/config_files/p2p.rs b/node-lib/src/config_files/p2p.rs
index 7d9fe36892..02cd664bee 100644
--- a/node-lib/src/config_files/p2p.rs
+++ b/node-lib/src/config_files/p2p.rs
@@ -73,10 +73,6 @@ pub struct P2pConfigFile {
     pub whitelisted_addresses: Option<Vec<IpAddr>>,
     /// Maximum allowed number of inbound connections.
     pub max_inbound_connections: Option<usize>,
-    /// The score threshold after which a peer is banned.
-    pub ban_threshold: Option<u32>,
-    /// Duration of bans in seconds.
-    pub ban_duration: Option<u64>,
     /// The score threshold after which a peer becomes discouraged.
     pub discouragement_threshold: Option<u32>,
     /// Duration of discouragement in seconds.
@@ -109,8 +105,6 @@ impl From<P2pConfigFile> for P2pConfig {
             reserved_nodes,
             whitelisted_addresses,
             max_inbound_connections,
-            ban_threshold,
-            ban_duration,
             discouragement_threshold,
             discouragement_duration,
             max_clock_diff,
@@ -130,8 +124,6 @@ impl From<P2pConfigFile> for P2pConfig {
             reserved_nodes: reserved_nodes.unwrap_or_default(),
             whitelisted_addresses: whitelisted_addresses.unwrap_or_default(),
             ban_config: BanConfig {
-                ban_threshold: ban_threshold.into(),
-                ban_duration: ban_duration.map(Duration::from_secs).into(),
                 discouragement_threshold: discouragement_threshold.into(),
                 discouragement_duration: discouragement_duration.map(Duration::from_secs).into(),
             },
diff --git a/node-lib/src/options.rs b/node-lib/src/options.rs
index 4c34ecef92..6c5554973d 100644
--- a/node-lib/src/options.rs
+++ b/node-lib/src/options.rs
@@ -136,11 +136,13 @@ pub struct RunOptions {
     #[clap(long)]
     pub p2p_max_inbound_connections: Option<usize>,
 
-    // TODO: add all the options related to banning/discouragement thresholds and durations,
-    // for completeness.
-    /// The p2p score threshold after which a peer is banned.
+    /// The p2p score threshold after which a peer is discouraged.
     #[clap(long)]
-    pub p2p_ban_threshold: Option<u32>,
+    pub p2p_discouragement_threshold: Option<u32>,
+
+    /// The p2p discouragement duration in seconds.
+    #[clap(long)]
+    pub p2p_discouragement_duration: Option<u64>,
 
     /// The p2p timeout value in seconds.
     #[clap(long)]
diff --git a/node-lib/tests/cli.rs b/node-lib/tests/cli.rs
index 76a93a632f..257ae4eee5 100644
--- a/node-lib/tests/cli.rs
+++ b/node-lib/tests/cli.rs
@@ -63,7 +63,14 @@ fn create_default_config() {
         .bind_addresses
         .unwrap_or_default()
         .is_empty());
-    assert_eq!(config.p2p.clone().unwrap_or_default().ban_threshold, None);
+    assert_eq!(
+        config.p2p.clone().unwrap_or_default().discouragement_threshold,
+        None
+    );
+    assert_eq!(
+        config.p2p.clone().unwrap_or_default().discouragement_duration,
+        None
+    );
     assert_eq!(
         config.p2p.clone().unwrap_or_default().outbound_connection_timeout,
         None
@@ -97,7 +104,8 @@ fn read_config_override_values() {
     let p2p_boot_node: IpOrSocketAddress = "127.0.0.1".parse().unwrap();
     let p2p_reserved_node: IpOrSocketAddress = "127.0.0.1".parse().unwrap();
     let p2p_max_inbound_connections = 123;
-    let p2p_ban_threshold = 3;
+    let p2p_discouragement_threshold = 3;
+    let p2p_discouragement_duration = 234;
     let p2p_timeout = NonZeroU64::new(10000).unwrap();
     let p2p_ping_check_period = 30;
     let p2p_ping_timeout = NonZeroU64::new(60).unwrap();
@@ -127,7 +135,8 @@ fn read_config_override_values() {
         p2p_boot_node: Some(vec![p2p_boot_node.clone()]),
         p2p_reserved_node: Some(vec![p2p_reserved_node.clone()]),
         p2p_max_inbound_connections: Some(p2p_max_inbound_connections),
-        p2p_ban_threshold: Some(p2p_ban_threshold),
+        p2p_discouragement_threshold: Some(p2p_discouragement_threshold),
+        p2p_discouragement_duration: Some(p2p_discouragement_duration),
         p2p_outbound_connection_timeout: Some(p2p_timeout),
         p2p_ping_check_period: Some(p2p_ping_check_period),
         p2p_ping_timeout: Some(p2p_ping_timeout),
@@ -201,8 +210,12 @@ fn read_config_override_values() {
         Some(p2p_max_inbound_connections)
     );
     assert_eq!(
-        config.p2p.clone().unwrap().ban_threshold,
-        Some(p2p_ban_threshold)
+        config.p2p.clone().unwrap().discouragement_threshold,
+        Some(p2p_discouragement_threshold)
+    );
+    assert_eq!(
+        config.p2p.clone().unwrap().discouragement_duration,
+        Some(p2p_discouragement_duration)
     );
     assert_eq!(
         config.p2p.clone().unwrap().outbound_connection_timeout,
diff --git a/p2p/benches/benches.rs b/p2p/benches/benches.rs
index da159d0280..c1c26eb92d 100644
--- a/p2p/benches/benches.rs
+++ b/p2p/benches/benches.rs
@@ -13,7 +13,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::{collections::BTreeSet, sync::Arc};
+use std::{collections::BTreeSet, sync::Arc, time::Duration};
 
 use common::chain::config::create_unit_test_config;
 use criterion::{criterion_group, criterion_main, Criterion};
@@ -35,7 +35,10 @@ pub fn peer_db(c: &mut Criterion) {
     }
 
     for _ in 0..1000 {
-        peerdb.ban(TestAddressMaker::new_random_address().as_bannable());
+        peerdb.ban(
+            TestAddressMaker::new_random_address().as_bannable(),
+            Duration::from_secs(60 * 60 * 24),
+        );
     }
 
     let outbound_addr_groups = (0..5)
diff --git a/p2p/src/ban_config.rs b/p2p/src/ban_config.rs
index e2a09652c6..735a43b236 100644
--- a/p2p/src/ban_config.rs
+++ b/p2p/src/ban_config.rs
@@ -17,22 +17,6 @@ use std::time::Duration;
 
 use utils::make_config_setting;
 
-make_config_setting!(BanThreshold, u32, 100);
-// TODO: initially, the ban duration was 24h, but later it was changed to 30 min because automatic
-// banning can be dangerous. E.g. it's possible for an attacker to force the node to use malicious
-// Tor exit nodes by making it ban all honest ones. Using a smaller interval seemed less dangerous,
-// so we chose 30 min. But even automatic disconnection of seemingly misbehaving peers may lead
-// to network splitting; e.g. if in a future version some previously incorrect behavior becomes
-// valid, the network may be split between old and new nodes, because the old ones would ban peers
-// that exhibit such behavior. Also, 30 min doesn't make much sense for manual banning. So, we
-// should probably get rid of automatic banning and return the old duration for the manual banning.
-// But if we decide to keep the auto-ban functionality:
-// a) the config names should be changed to AutoBanDuration, AutoBanThreshold;
-// b) manual banning should have a separate ManualBanDuration; or event better, the ban duration
-// should be specified by the user via RPC and the config should become ManualBanDefaultDuration.
-// c) there should be the ability to turn auto-banning off, e.g. by setting the threshold to 0;
-// by default, auto banning should be turned off.
-make_config_setting!(BanDuration, Duration, Duration::from_secs(60 * 30));
 make_config_setting!(DiscouragementThreshold, u32, 100);
 make_config_setting!(
     DiscouragementDuration,
@@ -40,14 +24,11 @@ make_config_setting!(
     Duration::from_secs(60 * 60 * 24)
 );
 
-/// Settings related to banning and discouragement.
+/// Settings related to banning in the general sense (i.e. to the handling of BanScore and
+/// potentially to manual banning as well).
 #[derive(Default, Debug, Clone)]
 pub struct BanConfig {
-    /// The score threshold after which a peer is banned.
-    pub ban_threshold: BanThreshold,
-    /// The duration of a ban.
-    pub ban_duration: BanDuration,
-    /// The score threshold after which a peer becomes discouraged.
+    /// The ban score threshold after which a peer becomes discouraged.
     pub discouragement_threshold: DiscouragementThreshold,
     /// The duration of discouragement.
     pub discouragement_duration: DiscouragementDuration,
diff --git a/p2p/src/error.rs b/p2p/src/error.rs
index 77cbcefd59..218e376d8f 100644
--- a/p2p/src/error.rs
+++ b/p2p/src/error.rs
@@ -127,8 +127,6 @@ pub enum DialError {
 pub enum ConversionError {
     #[error("Invalid address: {0}")]
     InvalidAddress(String),
-    #[error("Failed to decode data: {0}")]
-    DecodeError(serialization::Error),
 }
 
 #[derive(Error, Debug, PartialEq, Eq, Clone)]
@@ -186,12 +184,6 @@ impl From<std::io::Error> for P2pError {
     }
 }
 
-impl From<serialization::Error> for P2pError {
-    fn from(err: serialization::Error) -> P2pError {
-        P2pError::ConversionError(ConversionError::DecodeError(err))
-    }
-}
-
 impl From<tokio::sync::oneshot::error::RecvError> for P2pError {
     fn from(_: tokio::sync::oneshot::error::RecvError) -> P2pError {
         P2pError::ChannelClosed
@@ -272,7 +264,6 @@ impl BanScore for ConversionError {
     fn ban_score(&self) -> u32 {
         match self {
             ConversionError::InvalidAddress(_) => 0,
-            ConversionError::DecodeError(_) => 100,
         }
     }
 }
diff --git a/p2p/src/interface/p2p_interface.rs b/p2p/src/interface/p2p_interface.rs
index 04c5795e94..3f6cec92d5 100644
--- a/p2p/src/interface/p2p_interface.rs
+++ b/p2p/src/interface/p2p_interface.rs
@@ -13,9 +13,9 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::sync::Arc;
+use std::{sync::Arc, time::Duration};
 
-use common::chain::SignedTransaction;
+use common::{chain::SignedTransaction, primitives::time::Time};
 use mempool::tx_options::TxOptionsOverrides;
 use p2p_types::{
     bannable_address::BannableAddress, ip_or_socket_address::IpOrSocketAddress,
@@ -29,14 +29,17 @@ pub trait P2pInterface: Send + Sync {
     async fn connect(&mut self, addr: IpOrSocketAddress) -> crate::Result<()>;
     async fn disconnect(&mut self, peer_id: PeerId) -> crate::Result<()>;
 
-    async fn list_banned(&mut self) -> crate::Result<Vec<BannableAddress>>;
-    async fn ban(&mut self, addr: BannableAddress) -> crate::Result<()>;
+    async fn list_banned(&self) -> crate::Result<Vec<(BannableAddress, Time)>>;
+    async fn ban(&mut self, addr: BannableAddress, duration: Duration) -> crate::Result<()>;
     async fn unban(&mut self, addr: BannableAddress) -> crate::Result<()>;
 
+    async fn list_discouraged(&self) -> crate::Result<Vec<(BannableAddress, Time)>>;
+
     async fn get_peer_count(&self) -> crate::Result<usize>;
     async fn get_bind_addresses(&self) -> crate::Result<Vec<SocketAddress>>;
     async fn get_connected_peers(&self) -> crate::Result<Vec<ConnectedPeer>>;
 
+    async fn get_reserved_nodes(&self) -> crate::Result<Vec<SocketAddress>>;
     async fn add_reserved_node(&mut self, addr: IpOrSocketAddress) -> crate::Result<()>;
     async fn remove_reserved_node(&mut self, addr: IpOrSocketAddress) -> crate::Result<()>;
 
diff --git a/p2p/src/interface/p2p_interface_impl.rs b/p2p/src/interface/p2p_interface_impl.rs
index 4d996e4b78..256f84a76d 100644
--- a/p2p/src/interface/p2p_interface_impl.rs
+++ b/p2p/src/interface/p2p_interface_impl.rs
@@ -13,9 +13,9 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::sync::Arc;
+use std::{sync::Arc, time::Duration};
 
-use common::chain::SignedTransaction;
+use common::{chain::SignedTransaction, primitives::time::Time};
 use mempool::{
     tx_options::{TxOptions, TxOptionsOverrides},
     tx_origin::LocalTxOrigin,
@@ -61,7 +61,7 @@ where
         response_receiver.await?
     }
 
-    async fn list_banned(&mut self) -> crate::Result<Vec<BannableAddress>> {
+    async fn list_banned(&self) -> crate::Result<Vec<(BannableAddress, Time)>> {
         let (response_sender, response_receiver) = oneshot_nofail::channel();
         self.peer_mgr_event_sender
             .send(PeerManagerEvent::ListBanned(response_sender))
@@ -69,13 +69,15 @@ where
         let list = response_receiver.await?;
         Ok(list)
     }
-    async fn ban(&mut self, addr: BannableAddress) -> crate::Result<()> {
+
+    async fn ban(&mut self, addr: BannableAddress, duration: Duration) -> crate::Result<()> {
         let (response_sender, response_receiver) = oneshot_nofail::channel();
         self.peer_mgr_event_sender
-            .send(PeerManagerEvent::Ban(addr, response_sender))
+            .send(PeerManagerEvent::Ban(addr, duration, response_sender))
             .map_err(|_| P2pError::ChannelClosed)?;
         response_receiver.await?
     }
+
     async fn unban(&mut self, addr: BannableAddress) -> crate::Result<()> {
         let (response_sender, response_receiver) = oneshot_nofail::channel();
         self.peer_mgr_event_sender
@@ -84,6 +86,15 @@ where
         response_receiver.await?
     }
 
+    async fn list_discouraged(&self) -> crate::Result<Vec<(BannableAddress, Time)>> {
+        let (response_sender, response_receiver) = oneshot_nofail::channel();
+        self.peer_mgr_event_sender
+            .send(PeerManagerEvent::ListDiscouraged(response_sender))
+            .map_err(|_| P2pError::ChannelClosed)?;
+        let list = response_receiver.await?;
+        Ok(list)
+    }
+
     async fn get_peer_count(&self) -> crate::Result<usize> {
         let (response_sender, response_receiver) = oneshot_nofail::channel();
         self.peer_mgr_event_sender
@@ -105,6 +116,15 @@ where
         Ok(response_receiver.await?)
     }
 
+    async fn get_reserved_nodes(&self) -> crate::Result<Vec<SocketAddress>> {
+        let (response_sender, response_receiver) = oneshot_nofail::channel();
+        self.peer_mgr_event_sender
+            .send(PeerManagerEvent::GetReserved(response_sender))
+            .map_err(|_| P2pError::ChannelClosed)?;
+        let list = response_receiver.await?;
+        Ok(list)
+    }
+
     async fn add_reserved_node(&mut self, addr: IpOrSocketAddress) -> crate::Result<()> {
         let (response_sender, response_receiver) = oneshot_nofail::channel();
         self.peer_mgr_event_sender
diff --git a/p2p/src/interface/p2p_interface_impl_delegation.rs b/p2p/src/interface/p2p_interface_impl_delegation.rs
index e9e4107ee1..bc50e8daef 100644
--- a/p2p/src/interface/p2p_interface_impl_delegation.rs
+++ b/p2p/src/interface/p2p_interface_impl_delegation.rs
@@ -16,9 +16,10 @@
 use std::{
     ops::{Deref, DerefMut},
     sync::Arc,
+    time::Duration,
 };
 
-use common::chain::SignedTransaction;
+use common::{chain::SignedTransaction, primitives::time::Time};
 use mempool::tx_options::TxOptionsOverrides;
 use p2p_types::{
     bannable_address::BannableAddress, ip_or_socket_address::IpOrSocketAddress,
@@ -41,16 +42,22 @@ impl<T: Deref<Target = dyn P2pInterface> + DerefMut<Target = dyn P2pInterface> +
         self.deref_mut().disconnect(peer_id).await
     }
 
-    async fn list_banned(&mut self) -> crate::Result<Vec<BannableAddress>> {
-        self.deref_mut().list_banned().await
+    async fn list_banned(&self) -> crate::Result<Vec<(BannableAddress, Time)>> {
+        self.deref().list_banned().await
     }
-    async fn ban(&mut self, addr: BannableAddress) -> crate::Result<()> {
-        self.deref_mut().ban(addr).await
+
+    async fn ban(&mut self, addr: BannableAddress, duration: Duration) -> crate::Result<()> {
+        self.deref_mut().ban(addr, duration).await
     }
+
     async fn unban(&mut self, addr: BannableAddress) -> crate::Result<()> {
         self.deref_mut().unban(addr).await
     }
 
+    async fn list_discouraged(&self) -> crate::Result<Vec<(BannableAddress, Time)>> {
+        self.deref().list_discouraged().await
+    }
+
     async fn get_peer_count(&self) -> crate::Result<usize> {
         self.deref().get_peer_count().await
     }
@@ -63,6 +70,10 @@ impl<T: Deref<Target = dyn P2pInterface> + DerefMut<Target = dyn P2pInterface> +
         self.deref().get_connected_peers().await
     }
 
+    async fn get_reserved_nodes(&self) -> crate::Result<Vec<SocketAddress>> {
+        self.deref().get_reserved_nodes().await
+    }
+
     async fn add_reserved_node(&mut self, addr: IpOrSocketAddress) -> crate::Result<()> {
         self.deref_mut().add_reserved_node(addr).await
     }
diff --git a/p2p/src/peer_manager/config.rs b/p2p/src/peer_manager/config.rs
index 739914cbbe..585db6b5d1 100644
--- a/p2p/src/peer_manager/config.rs
+++ b/p2p/src/peer_manager/config.rs
@@ -43,7 +43,7 @@ make_config_setting!(ForceDnsQueryIfNoGlobalAddressesKnown, bool, false);
 make_config_setting!(AllowSameIpConnections, bool, false);
 
 // TODO: this name is too generic, because not all peer manager settings are contained here.
-// PeerManagerInternalConfig would be a better name.
+// PeerManagerInternalConfig might be a better name.
 // Alternatively, we may want to actually put all peer manager settings here. If we do this,
 // it might be better to revise the entire structure of p2p config and make it more hierarchical.
 // E.g. we may have separate structs for backend, sync manager and peer manager settings at the
diff --git a/p2p/src/peer_manager/mod.rs b/p2p/src/peer_manager/mod.rs
index 6563795c10..2e51db338c 100644
--- a/p2p/src/peer_manager/mod.rs
+++ b/p2p/src/peer_manager/mod.rs
@@ -429,8 +429,8 @@ where
 
     /// Adjust peer score
     ///
-    /// Discourage and/or ban the peer if the score reaches the corresponding threshold.
-    fn adjust_peer_score(&mut self, peer_id: PeerId, score_adjustment: u32) {
+    /// Discourage the peer if the score reaches the corresponding threshold.
+    fn adjust_peer_score(&mut self, peer_id: PeerId, score: u32) {
         let peer = match self.peers.get(&peer_id) {
             Some(peer) => peer,
             None => return,
@@ -438,7 +438,7 @@ where
 
         if self.is_whitelisted_node(peer.peer_role, &peer.peer_address) {
             log::info!(
-                "Not adjusting peer score for the whitelisted peer {peer_id}, adjustment {score_adjustment}",
+                "Not adjusting peer score for the whitelisted peer {peer_id}, adjustment {score}",
             );
             return;
         }
@@ -448,24 +448,20 @@ where
             None => return,
         };
 
-        let new_score = peer.score.saturating_add(score_adjustment);
-        let peer_address = peer.peer_address.as_bannable();
-        peer.score = new_score;
+        peer.score = peer.score.saturating_add(score);
 
         log::info!(
-            "Adjusting peer score for peer {peer_id}, adjustment {score_adjustment}, new score {new_score}",
+            "Adjusting peer score for peer {peer_id}, adjustment {score}, new score {}",
+            peer.score
         );
 
         if let Some(o) = self.observer.as_mut() {
             o.on_peer_ban_score_adjustment(peer.peer_address, peer.score)
         }
 
-        if new_score >= *self.p2p_config.ban_config.ban_threshold {
-            self.ban(peer_address);
-        }
-
-        if new_score >= *self.p2p_config.ban_config.discouragement_threshold {
-            self.discourage(peer_address);
+        if peer.score >= *self.p2p_config.ban_config.discouragement_threshold {
+            let address = peer.peer_address.as_bannable();
+            self.discourage(address);
         }
     }
 
@@ -494,20 +490,14 @@ where
             o.on_peer_ban_score_adjustment(peer_address, score);
         }
 
-        if score >= *self.p2p_config.ban_config.ban_threshold {
-            let address = peer_address.as_bannable();
-            self.ban(address);
-        }
-
         if score >= *self.p2p_config.ban_config.discouragement_threshold {
             let address = peer_address.as_bannable();
             self.discourage(address);
         }
     }
 
-    fn ban(&mut self, address: BannableAddress) {
-        let to_disconnect = self
-            .peers
+    fn bannable_peers_for_addr(&self, address: BannableAddress) -> Vec<PeerId> {
+        self.peers
             .values()
             .filter_map(|peer| {
                 if peer.peer_address.as_bannable() == address {
@@ -516,7 +506,11 @@ where
                     None
                 }
             })
-            .collect::<Vec<_>>();
+            .collect::<Vec<_>>()
+    }
+
+    fn ban(&mut self, address: BannableAddress, duration: Duration) {
+        let to_disconnect = self.bannable_peers_for_addr(address);
 
         log::info!(
             "Banning {:?}, the following peers will be disconnected: {:?}",
@@ -524,7 +518,7 @@ where
             to_disconnect
         );
 
-        self.peerdb.ban(address);
+        self.peerdb.ban(address, duration);
 
         if let Some(o) = self.observer.as_mut() {
             o.on_peer_ban(address);
@@ -536,13 +530,23 @@ where
     }
 
     fn discourage(&mut self, address: BannableAddress) {
-        log::info!("Discouraging {address:?}");
+        let to_disconnect = self.bannable_peers_for_addr(address);
+
+        log::info!(
+            "Discouraging {:?}, the following peers will be disconnected: {:?}",
+            address,
+            to_disconnect
+        );
 
         self.peerdb.discourage(address);
 
         if let Some(o) = self.observer.as_mut() {
             o.on_peer_discouragement(address);
         }
+
+        for peer_id in to_disconnect {
+            self.disconnect(peer_id, PeerDisconnectionDbAction::Keep, None);
+        }
     }
 
     /// Try to initiate a new outbound connection
@@ -698,7 +702,7 @@ where
         // Ok and for outbound ones we've already called it in try_connect. But new connections
         // might have appeared since try_connect was called, so the call below is not redundant.
         self.maybe_reject_because_already_connected(address, peer_role)?;
-        
+
         // Note: for outbound connections, ban and discouragement statuses have already been
         // checked in try_connect, so when we do the checks here, they'll only work for
         // inbound connections. And since inbound connections from discouraged addresses are
@@ -722,10 +726,16 @@ where
                 // TODO: Always allow connections from the whitelisted IPs
                 if self.inbound_peer_count()
                     >= *self.p2p_config.peer_manager_config.max_inbound_connections
-                    && !self.try_evict_random_inbound_connection()
                 {
-                    log::info!("no peer is selected for eviction, new connection is dropped");
-                    return Err(P2pError::PeerError(PeerError::TooManyPeers));
+                    if self.peerdb.is_address_discouraged(&address.as_bannable()) {
+                        log::info!("Rejecting inbound connection from a discouraged address - too many peers");
+                        return Err(P2pError::PeerError(PeerError::TooManyPeers));
+                    }
+
+                    if !self.try_evict_random_inbound_connection() {
+                        log::info!("Rejecting inbound connection - too many peers and none of them can be evicted");
+                        return Err(P2pError::PeerError(PeerError::TooManyPeers));
+                    }
                 }
             }
 
@@ -1170,6 +1180,7 @@ where
         let mut cur_feeler_conn_count = 0;
         let mut cur_outbound_conn_addr_groups = BTreeSet::new();
         let mut cur_conn_ip_port_to_role_map = BTreeMap::new();
+
         for (addr, role) in self.peer_addresses_iter() {
             let addr_group = AddressGroup::from_peer_address(&addr.as_peer_address());
 
@@ -1369,7 +1380,7 @@ where
             })
             // Note: some of the addresses may have become banned or discouraged after they've been
             // cached. It's not clear whether it's better to filter them out here, which will
-            // reveal to peers what addresses we've ban or discouraged, or keep them as is.
+            // reveal to peers what addresses we've banned or discouraged, or keep them as is.
             // But it's probably not that important.
             .clone();
 
@@ -1515,6 +1526,9 @@ where
                 let peers = self.get_connected_peers();
                 response_sender.send(peers);
             }
+            PeerManagerEvent::GetReserved(response_sender) => {
+                response_sender.send(self.peerdb.get_reserved_nodes().collect())
+            }
             PeerManagerEvent::AddReserved(address, response_sender) => {
                 let address = ip_or_socket_address_to_peer_address(&address, &self.chain_config);
                 self.peerdb.add_reserved_node(address);
@@ -1528,16 +1542,19 @@ where
                 response_sender.send(Ok(()));
             }
             PeerManagerEvent::ListBanned(response_sender) => {
-                response_sender.send(self.peerdb.list_banned().cloned().collect())
+                response_sender.send(self.peerdb.list_banned().collect())
             }
-            PeerManagerEvent::Ban(address, response_sender) => {
-                self.ban(address);
+            PeerManagerEvent::Ban(address, duration, response_sender) => {
+                self.ban(address, duration);
                 response_sender.send(Ok(()));
             }
             PeerManagerEvent::Unban(address, response_sender) => {
                 self.peerdb.unban(&address);
                 response_sender.send(Ok(()));
             }
+            PeerManagerEvent::ListDiscouraged(response_sender) => {
+                response_sender.send(self.peerdb.list_discouraged().collect())
+            }
             PeerManagerEvent::GenericQuery(query_func) => {
                 query_func(self);
             }
diff --git a/p2p/src/peer_manager/peerdb/mod.rs b/p2p/src/peer_manager/peerdb/mod.rs
index 6e327376df..4a04b63c04 100644
--- a/p2p/src/peer_manager/peerdb/mod.rs
+++ b/p2p/src/peer_manager/peerdb/mod.rs
@@ -35,6 +35,7 @@ mod storage_load;
 use std::{
     collections::{btree_map::Entry, BTreeMap, BTreeSet},
     sync::Arc,
+    time::Duration,
 };
 
 use common::{chain::ChainConfig, primitives::time::Time, time_getter::TimeGetter};
@@ -487,7 +488,7 @@ impl<S: PeerDbStorage> PeerDb<S> {
             // that haven't been advertised in a while?
             // 3) also store last_connect_time in AddressData to avoid removing addresses
             // that we've recently connected to?
-            // 4) Allow removing banned addresses?
+            // 4) Allow removing banned/discouraged addresses?
             existing_addr_data.reserved() || existing_addr_data.is_unreachable()
         } else {
             debug_assert!(
@@ -537,6 +538,10 @@ impl<S: PeerDbStorage> PeerDb<S> {
         self.reserved_nodes.contains(address)
     }
 
+    pub fn get_reserved_nodes(&self) -> impl Iterator<Item = SocketAddress> + '_ {
+        self.reserved_nodes.iter().copied()
+    }
+
     pub fn add_reserved_node(&mut self, address: SocketAddress) {
         self.change_address_state(address, AddressStateTransitionTo::SetReserved);
         self.reserved_nodes.insert(address);
@@ -552,14 +557,13 @@ impl<S: PeerDbStorage> PeerDb<S> {
         self.banned_addresses.contains_key(address)
     }
 
-    pub fn list_banned(&self) -> impl Iterator<Item = &BannableAddress> {
-        self.banned_addresses.keys()
+    pub fn list_banned(&self) -> impl Iterator<Item = (BannableAddress, Time)> + '_ {
+        self.banned_addresses.iter().map(|(addr, time)| (*addr, *time))
     }
 
     /// Changes the address state to banned
-    pub fn ban(&mut self, address: BannableAddress) {
-        let ban_till = (self.time_getter.get_time() + *self.p2p_config.ban_config.ban_duration)
-            .expect("Ban duration is expected to be valid");
+    pub fn ban(&mut self, address: BannableAddress, duration: Duration) {
+        let ban_till = self.time_getter.get_time().saturating_duration_add(duration);
 
         update_db(&self.storage, |tx| {
             tx.add_banned_address(&address, ban_till)
@@ -581,12 +585,16 @@ impl<S: PeerDbStorage> PeerDb<S> {
         self.discouraged_addresses.contains_key(address)
     }
 
+    pub fn list_discouraged(&self) -> impl Iterator<Item = (BannableAddress, Time)> + '_ {
+        self.discouraged_addresses.iter().map(|(addr, time)| (*addr, *time))
+    }
+
     /// Changes the address state to discouraged
     pub fn discourage(&mut self, address: BannableAddress) {
-        // TODO: do we need to prolong the discouragement if the peer continues misbehaving?
-        let discourage_till = (self.time_getter.get_time()
-            + *self.p2p_config.ban_config.discouragement_duration)
-            .expect("Discouragement duration is expected to be valid");
+        let discourage_till = self
+            .time_getter
+            .get_time()
+            .saturating_duration_add(*self.p2p_config.ban_config.discouragement_duration);
 
         update_db(&self.storage, |tx| {
             tx.add_discouraged_address(&address, discourage_till)
diff --git a/p2p/src/peer_manager/peerdb/tests.rs b/p2p/src/peer_manager/peerdb/tests.rs
index 57e076be82..15eee304a2 100644
--- a/p2p/src/peer_manager/peerdb/tests.rs
+++ b/p2p/src/peer_manager/peerdb/tests.rs
@@ -24,7 +24,7 @@ use itertools::Itertools;
 use rstest::rstest;
 
 use ::test_utils::random::{make_seedable_rng, Seed};
-use common::chain::config::create_unit_test_config;
+use common::{chain::config::create_unit_test_config, primitives::time::Time};
 use crypto::random::Rng;
 use p2p_test_utils::P2pBasicTestTimeGetter;
 
@@ -54,19 +54,19 @@ use super::{
     PeerDb,
 };
 
+// Ban the peer, check that it's banned.
+// Wait for the duration of the ban, check that it's no longer banned.
 #[tracing::instrument]
 #[test]
-fn unban_peer() {
+fn ban_peer() {
     let db_store = peerdb_inmemory_store();
     let time_getter = P2pBasicTestTimeGetter::new();
     let chain_config = create_unit_test_config();
+    let ban_duration = Duration::from_secs(60);
     let mut peerdb = PeerDb::<_>::new(
         &chain_config,
         Arc::new(test_p2p_config_with_ban_config(BanConfig {
-            ban_duration: Duration::from_secs(60).into(),
             discouragement_duration: Duration::from_secs(600).into(),
-
-            ban_threshold: Default::default(),
             discouragement_threshold: Default::default(),
         })),
         time_getter.get_time_getter(),
@@ -75,13 +75,17 @@ fn unban_peer() {
     .unwrap();
 
     let address = TestAddressMaker::new_random_address();
-    peerdb.ban(address.as_bannable());
+    peerdb.ban(address.as_bannable(), ban_duration);
 
     // The address is banned.
     assert!(peerdb.is_address_banned(&address.as_bannable()));
     let banned_addresses = peerdb.storage.transaction_ro().unwrap().get_banned_addresses().unwrap();
     assert_eq!(banned_addresses.len(), 1);
     assert_eq!(banned_addresses[0].0, address.as_bannable());
+    assert_eq!(
+        banned_addresses[0].1,
+        (time_getter.get_time_getter().get_time() + ban_duration).unwrap()
+    );
 
     // But not discouraged.
     assert!(!peerdb.is_address_discouraged(&address.as_bannable()));
@@ -89,7 +93,7 @@ fn unban_peer() {
         peerdb.storage.transaction_ro().unwrap().get_discouraged_addresses().unwrap();
     assert_eq!(discouraged_addresses.len(), 0);
 
-    time_getter.advance_time(Duration::from_secs(120));
+    time_getter.advance_time(ban_duration);
 
     // Banned addresses are updated in the `heartbeat` function
     peerdb.heartbeat();
@@ -108,19 +112,100 @@ fn unban_peer() {
     assert_addr_consistency(&peerdb);
 }
 
+// Ban the peer twice, check that the second duration overrides the first one.
 #[tracing::instrument]
 #[test]
-fn undiscourage_peer() {
+fn ban_peer_twice() {
     let db_store = peerdb_inmemory_store();
     let time_getter = P2pBasicTestTimeGetter::new();
     let chain_config = create_unit_test_config();
+    let ban_duration1 = Duration::from_secs(60);
+    let ban_duration2 = Duration::from_secs(120);
     let mut peerdb = PeerDb::<_>::new(
         &chain_config,
         Arc::new(test_p2p_config_with_ban_config(BanConfig {
-            discouragement_duration: Duration::from_secs(60).into(),
-            ban_duration: Duration::from_secs(600).into(),
+            discouragement_duration: Duration::from_secs(600).into(),
+            discouragement_threshold: Default::default(),
+        })),
+        time_getter.get_time_getter(),
+        db_store,
+    )
+    .unwrap();
+
+    let address = TestAddressMaker::new_random_address();
+
+    peerdb.ban(address.as_bannable(), ban_duration1);
+
+    // The address is banned for ban_duration1.
+    assert!(peerdb.is_address_banned(&address.as_bannable()));
+    let banned_addresses = peerdb.storage.transaction_ro().unwrap().get_banned_addresses().unwrap();
+    assert_eq!(banned_addresses.len(), 1);
+    assert_eq!(banned_addresses[0].0, address.as_bannable());
+    assert_eq!(
+        banned_addresses[0].1,
+        (time_getter.get_time_getter().get_time() + ban_duration1).unwrap()
+    );
+
+    peerdb.ban(address.as_bannable(), ban_duration2);
+
+    // The address is banned for ban_duration2.
+    assert!(peerdb.is_address_banned(&address.as_bannable()));
+    let banned_addresses = peerdb.storage.transaction_ro().unwrap().get_banned_addresses().unwrap();
+    assert_eq!(banned_addresses.len(), 1);
+    assert_eq!(banned_addresses[0].0, address.as_bannable());
+    assert_eq!(
+        banned_addresses[0].1,
+        (time_getter.get_time_getter().get_time() + ban_duration2).unwrap()
+    );
+
+    assert_addr_consistency(&peerdb);
+}
+
+// Ban the peer for Duration::MAX; the ban end time should be the maximum possible time.
+#[tracing::instrument]
+#[test]
+fn ban_for_max_duration() {
+    let db_store = peerdb_inmemory_store();
+    let time_getter = P2pBasicTestTimeGetter::new();
+    let chain_config = create_unit_test_config();
+    let mut peerdb = PeerDb::<_>::new(
+        &chain_config,
+        Arc::new(test_p2p_config()),
+        time_getter.get_time_getter(),
+        db_store,
+    )
+    .unwrap();
+
+    let address = TestAddressMaker::new_random_address();
+
+    peerdb.ban(address.as_bannable(), Duration::MAX);
+
+    // The address is banned until the maximum possible time.
+    assert!(peerdb.is_address_banned(&address.as_bannable()));
+    let banned_addresses = peerdb.storage.transaction_ro().unwrap().get_banned_addresses().unwrap();
+    assert_eq!(banned_addresses.len(), 1);
+    assert_eq!(banned_addresses[0].0, address.as_bannable());
+    assert_eq!(
+        banned_addresses[0].1,
+        Time::from_duration_since_epoch(Duration::MAX)
+    );
+
+    assert_addr_consistency(&peerdb);
+}
 
-            ban_threshold: Default::default(),
+// Discourage the peer, check that it's discouraged.
+// Wait for the duration of the discouragement, check that it's no longer discouraged.
+#[tracing::instrument]
+#[test]
+fn discourage_peer() {
+    let db_store = peerdb_inmemory_store();
+    let time_getter = P2pBasicTestTimeGetter::new();
+    let chain_config = create_unit_test_config();
+    let discouragement_duration = Duration::from_secs(60);
+    let mut peerdb = PeerDb::<_>::new(
+        &chain_config,
+        Arc::new(test_p2p_config_with_ban_config(BanConfig {
+            discouragement_duration: discouragement_duration.into(),
             discouragement_threshold: Default::default(),
         })),
         time_getter.get_time_getter(),
@@ -137,13 +222,17 @@ fn undiscourage_peer() {
         peerdb.storage.transaction_ro().unwrap().get_discouraged_addresses().unwrap();
     assert_eq!(discouraged_addresses.len(), 1);
     assert_eq!(discouraged_addresses[0].0, address.as_bannable());
+    assert_eq!(
+        discouraged_addresses[0].1,
+        (time_getter.get_time_getter().get_time() + discouragement_duration).unwrap()
+    );
 
     // But not banned.
     assert!(!peerdb.is_address_banned(&address.as_bannable()));
     let banned_addresses = peerdb.storage.transaction_ro().unwrap().get_banned_addresses().unwrap();
     assert_eq!(banned_addresses.len(), 0);
 
-    time_getter.advance_time(Duration::from_secs(120));
+    time_getter.advance_time(discouragement_duration);
 
     // Discouraged addresses are updated in the `heartbeat` function
     peerdb.heartbeat();
@@ -162,6 +251,107 @@ fn undiscourage_peer() {
     assert_addr_consistency(&peerdb);
 }
 
+// Discourage the peer, wait for some time then discourage it again. The discouragement duration
+// should be refreshed.
+#[tracing::instrument]
+#[test]
+fn discourage_peer_twice() {
+    let db_store = peerdb_inmemory_store();
+    let time_getter = P2pBasicTestTimeGetter::new();
+    let chain_config = create_unit_test_config();
+    let discouragement_duration = Duration::from_secs(60);
+    let mut peerdb = PeerDb::<_>::new(
+        &chain_config,
+        Arc::new(test_p2p_config_with_ban_config(BanConfig {
+            discouragement_duration: discouragement_duration.into(),
+            discouragement_threshold: Default::default(),
+        })),
+        time_getter.get_time_getter(),
+        db_store,
+    )
+    .unwrap();
+
+    let address = TestAddressMaker::new_random_address();
+
+    peerdb.discourage(address.as_bannable());
+
+    // The address is discouraged for discouragement_duration.
+    assert!(peerdb.is_address_discouraged(&address.as_bannable()));
+    let discouraged_addresses =
+        peerdb.storage.transaction_ro().unwrap().get_discouraged_addresses().unwrap();
+    assert_eq!(discouraged_addresses.len(), 1);
+    assert_eq!(discouraged_addresses[0].0, address.as_bannable());
+    assert_eq!(
+        discouraged_addresses[0].1,
+        (time_getter.get_time_getter().get_time() + discouragement_duration).unwrap()
+    );
+
+    time_getter.advance_time(discouragement_duration / 2);
+
+    // The peer is still discouraged, the remaining duration is discouragement_duration/2.
+    assert!(peerdb.is_address_discouraged(&address.as_bannable()));
+    let discouraged_addresses =
+        peerdb.storage.transaction_ro().unwrap().get_discouraged_addresses().unwrap();
+    assert_eq!(discouraged_addresses.len(), 1);
+    assert_eq!(discouraged_addresses[0].0, address.as_bannable());
+    assert_eq!(
+        discouraged_addresses[0].1,
+        (time_getter.get_time_getter().get_time() + discouragement_duration / 2).unwrap()
+    );
+
+    // Discourage it the second time
+    peerdb.discourage(address.as_bannable());
+
+    // The address is again discouraged for the full discouragement_duration.
+    assert!(peerdb.is_address_discouraged(&address.as_bannable()));
+    let discouraged_addresses =
+        peerdb.storage.transaction_ro().unwrap().get_discouraged_addresses().unwrap();
+    assert_eq!(discouraged_addresses.len(), 1);
+    assert_eq!(discouraged_addresses[0].0, address.as_bannable());
+    assert_eq!(
+        discouraged_addresses[0].1,
+        (time_getter.get_time_getter().get_time() + discouragement_duration).unwrap()
+    );
+
+    assert_addr_consistency(&peerdb);
+}
+
+// Discourage the peer for Duration::MAX; the discouragement end time should be
+// the maximum possible time.
+#[tracing::instrument]
+#[test]
+fn discourage_for_max_duration() {
+    let db_store = peerdb_inmemory_store();
+    let time_getter = P2pBasicTestTimeGetter::new();
+    let chain_config = create_unit_test_config();
+    let mut peerdb = PeerDb::<_>::new(
+        &chain_config,
+        Arc::new(test_p2p_config_with_ban_config(BanConfig {
+            discouragement_duration: Duration::MAX.into(),
+            discouragement_threshold: Default::default(),
+        })),
+        time_getter.get_time_getter(),
+        db_store,
+    )
+    .unwrap();
+
+    let address = TestAddressMaker::new_random_address();
+    peerdb.discourage(address.as_bannable());
+
+    // The address is discouraged until the maximum possible time.
+    assert!(peerdb.is_address_discouraged(&address.as_bannable()));
+    let discouraged_addresses =
+        peerdb.storage.transaction_ro().unwrap().get_discouraged_addresses().unwrap();
+    assert_eq!(discouraged_addresses.len(), 1);
+    assert_eq!(discouraged_addresses[0].0, address.as_bannable());
+    assert_eq!(
+        discouraged_addresses[0].1,
+        Time::from_duration_since_epoch(Duration::MAX)
+    );
+
+    assert_addr_consistency(&peerdb);
+}
+
 #[tracing::instrument]
 #[test]
 fn connected_unreachable() {
diff --git a/p2p/src/peer_manager/peers_eviction/mod.rs b/p2p/src/peer_manager/peers_eviction/mod.rs
index 5d029b4ad8..7505d65bd5 100644
--- a/p2p/src/peer_manager/peers_eviction/mod.rs
+++ b/p2p/src/peer_manager/peers_eviction/mod.rs
@@ -306,6 +306,10 @@ fn select_for_eviction_outbound(
         return None;
     }
 
+    // Note: currently, this 'is_banned_or_discouraged' condition can only happen in tests, because,
+    // from the one hand, automatic outbound connections are never established to banned or
+    // discouraged peers and, from the other hand, peers are always automatically disconnected
+    // when they receive the banned or discouraged status.
     if let Some(candidate) = candidates.iter().filter(|ec| ec.is_banned_or_discouraged).choose(rng)
     {
         return Some(candidate.peer_id);
diff --git a/p2p/src/peer_manager/tests/ban.rs b/p2p/src/peer_manager/tests/ban.rs
index f2ca52555b..8d1e9bfbc9 100644
--- a/p2p/src/peer_manager/tests/ban.rs
+++ b/p2p/src/peer_manager/tests/ban.rs
@@ -50,23 +50,22 @@ use common::{chain::config, primitives::user_agent::mintlayer_core_user_agent};
 use p2p_test_utils::{expect_no_recv, expect_recv, wait_for_no_recv, P2pBasicTestTimeGetter};
 use test_utils::random::{make_seedable_rng, Seed};
 
-// Check that a peer is automatically banned once the ban threshold is reached.
-// Also check that it's disconnected once banned, and that it's unbanned once the ban
-// duration has expired.
+// Check that a peer is not banned automatically.
 #[tracing::instrument(skip(seed))]
 #[rstest]
 #[trace]
 #[case(Seed::from_entropy())]
 #[tokio::test]
-async fn auto_ban_connected_peer(#[case] seed: Seed) {
+async fn dont_auto_ban_connected_peer(#[case] seed: Seed) {
     let mut rng = make_seedable_rng(seed);
 
     let chain_config = Arc::new(config::create_unit_test_config());
+    let test_score = 1000;
     let ban_config = BanConfig {
-        ban_threshold: 100.into(),
-        ban_duration: Duration::from_secs(60 * 60).into(),
-        discouragement_threshold: 1000.into(),
-        discouragement_duration: Duration::from_secs(60 * 60 * 10).into(),
+        // Make sure that discouragement mechanics doesn't kick in.
+        discouragement_threshold: (test_score + 1).into(),
+
+        discouragement_duration: Default::default(),
     };
     let p2p_config = Arc::new(test_p2p_config_with_ban_config(ban_config.clone()));
 
@@ -78,7 +77,7 @@ async fn auto_ban_connected_peer(#[case] seed: Seed) {
         conn_event_sender,
         peer_mgr_event_sender,
         mut cmd_receiver,
-        mut peer_mgr_notification_receiver,
+        _peer_mgr_notification_receiver,
     ) = make_standalone_peer_manager(
         Arc::clone(&chain_config),
         Arc::clone(&p2p_config),
@@ -103,13 +102,8 @@ async fn auto_ban_connected_peer(#[case] seed: Seed) {
     let cmd = expect_recv!(cmd_receiver);
     assert_eq!(cmd, Command::Accept { peer_id });
 
-    // Increase the score by 1/2 of the threshold, check that the peer is not banned.
-    adjust_peer_score(
-        &peer_mgr_event_sender,
-        peer_id,
-        *ban_config.ban_threshold / 2,
-    )
-    .await;
+    // Increase the score by a large amount, check that the peer is not banned.
+    adjust_peer_score(&peer_mgr_event_sender, peer_id, test_score).await;
 
     let is_banned = query_peer_manager(&peer_mgr_event_sender, move |peer_mgr| {
         peer_mgr.peer_db().is_address_banned(&peer_addr.as_bannable())
@@ -117,39 +111,9 @@ async fn auto_ban_connected_peer(#[case] seed: Seed) {
     .await;
     assert!(!is_banned);
 
+    // No disconnection happens
     expect_no_recv!(cmd_receiver);
 
-    // Increase the score by 1/2 of the threshold again, check that the peer is banned now.
-    adjust_peer_score(
-        &peer_mgr_event_sender,
-        peer_id,
-        *ban_config.ban_threshold / 2,
-    )
-    .await;
-
-    let is_banned = query_peer_manager(&peer_mgr_event_sender, move |peer_mgr| {
-        peer_mgr.peer_db().is_address_banned(&peer_addr.as_bannable())
-    })
-    .await;
-    assert!(is_banned);
-
-    // The banned peer should be disconnected.
-    let cmd = expect_recv!(cmd_receiver);
-    assert_eq!(cmd, Command::Disconnect { peer_id });
-
-    wait_for_no_recv(&mut peer_mgr_notification_receiver).await;
-
-    // Wait for ban duration to pass; check that the peer is no longer banned.
-    time_getter.advance_time(*ban_config.ban_duration);
-
-    wait_for_heartbeat(&mut peer_mgr_notification_receiver).await;
-
-    let is_banned = query_peer_manager(&peer_mgr_event_sender, move |peer_mgr| {
-        peer_mgr.peer_db().is_address_banned(&peer_addr.as_bannable())
-    })
-    .await;
-    assert!(!is_banned);
-
     drop(conn_event_sender);
     drop(peer_mgr_event_sender);
 
@@ -167,16 +131,11 @@ async fn disconnect_manually_banned_peer(#[case] seed: Seed) {
     let mut rng = make_seedable_rng(seed);
 
     let chain_config = Arc::new(config::create_unit_test_config());
-    let ban_config = BanConfig {
-        ban_threshold: Default::default(),
-        ban_duration: Duration::from_secs(60 * 60).into(),
-        discouragement_threshold: Default::default(),
-        discouragement_duration: Duration::from_secs(60 * 60 * 10).into(),
-    };
-    let p2p_config = Arc::new(test_p2p_config_with_ban_config(ban_config.clone()));
+    let p2p_config = Arc::new(test_p2p_config());
 
     let time_getter = P2pBasicTestTimeGetter::new();
     let bind_addr = TestTransportTcp::make_address();
+    let ban_duration = Duration::from_secs(60 * 60);
 
     let (
         peer_mgr,
@@ -214,7 +173,12 @@ async fn disconnect_manually_banned_peer(#[case] seed: Seed) {
     .await;
     assert!(!is_banned);
 
-    ban_peer_manually(&peer_mgr_event_sender, peer_addr.as_bannable()).await;
+    ban_peer_manually(
+        &peer_mgr_event_sender,
+        peer_addr.as_bannable(),
+        ban_duration,
+    )
+    .await;
 
     let is_banned = query_peer_manager(&peer_mgr_event_sender, move |peer_mgr| {
         peer_mgr.peer_db().is_address_banned(&peer_addr.as_bannable())
@@ -227,7 +191,7 @@ async fn disconnect_manually_banned_peer(#[case] seed: Seed) {
 
     wait_for_no_recv(&mut peer_mgr_notification_receiver).await;
 
-    time_getter.advance_time(*ban_config.ban_duration);
+    time_getter.advance_time(ban_duration);
 
     wait_for_heartbeat(&mut peer_mgr_notification_receiver).await;
 
@@ -257,6 +221,7 @@ async fn reject_incoming_connection_from_banned_peer(#[case] seed: Seed) {
 
     let time_getter = P2pBasicTestTimeGetter::new();
     let bind_addr = TestTransportTcp::make_address();
+    let ban_duration = Duration::from_secs(60 * 60);
 
     let (mut peer_mgr, conn_event_sender, peer_mgr_event_sender, mut cmd_receiver, _) =
         make_standalone_peer_manager(
@@ -273,7 +238,7 @@ async fn reject_incoming_connection_from_banned_peer(#[case] seed: Seed) {
     );
     let [banned_addr, normal_addr]: [_; 2] = peer_addrs.try_into().unwrap();
 
-    peer_mgr.ban(banned_addr.as_bannable());
+    peer_mgr.ban(banned_addr.as_bannable(), ban_duration);
 
     let peer_mgr_join_handle = logging::spawn_in_current_span(async move {
         let mut peer_mgr = peer_mgr;
@@ -341,6 +306,7 @@ async fn no_outgoing_connection_to_banned_peer(#[case] seed: Seed) {
 
     let time_getter = P2pBasicTestTimeGetter::new();
     let bind_addr = TestTransportTcp::make_address();
+    let ban_duration = Duration::from_secs(60 * 60);
 
     let (mut peer_mgr, conn_event_sender, peer_mgr_event_sender, mut cmd_receiver, _) =
         make_standalone_peer_manager(
@@ -360,7 +326,7 @@ async fn no_outgoing_connection_to_banned_peer(#[case] seed: Seed) {
     peer_mgr.peerdb.peer_discovered(banned_addr);
     peer_mgr.peerdb.peer_discovered(normal_addr);
 
-    peer_mgr.ban(banned_addr.as_bannable());
+    peer_mgr.ban(banned_addr.as_bannable(), ban_duration);
 
     let peer_mgr_join_handle = logging::spawn_in_current_span(async move {
         let mut peer_mgr = peer_mgr;
@@ -423,6 +389,7 @@ async fn banned_address_is_not_announced(#[case] seed: Seed) {
 
     let time_getter = P2pBasicTestTimeGetter::new();
     let bind_addr = TestTransportTcp::make_address();
+    let ban_duration = Duration::from_secs(60 * 60);
 
     let (mut peer_mgr, conn_event_sender, peer_mgr_event_sender, mut cmd_receiver, _) =
         make_standalone_peer_manager(
@@ -439,7 +406,7 @@ async fn banned_address_is_not_announced(#[case] seed: Seed) {
     );
     let [banned_addr, normal_addr, peer1_addr, peer2_addr]: [_; 4] = addrs.try_into().unwrap();
 
-    peer_mgr.ban(banned_addr.as_bannable());
+    peer_mgr.ban(banned_addr.as_bannable(), ban_duration);
 
     let peer_mgr_join_handle = logging::spawn_in_current_span(async move {
         let mut peer_mgr = peer_mgr;
@@ -542,6 +509,7 @@ async fn banned_address_not_in_addr_response(#[case] seed: Seed) {
 
     let time_getter = P2pBasicTestTimeGetter::new();
     let bind_addr = TestTransportTcp::make_address();
+    let ban_duration = Duration::from_secs(60 * 60);
 
     let (mut peer_mgr, conn_event_sender, peer_mgr_event_sender, mut cmd_receiver, _) =
         make_standalone_peer_manager(
@@ -561,7 +529,7 @@ async fn banned_address_not_in_addr_response(#[case] seed: Seed) {
     peer_mgr.peerdb.peer_discovered(banned_addr);
     peer_mgr.peerdb.peer_discovered(normal_addr);
 
-    peer_mgr.ban(banned_addr.as_bannable());
+    peer_mgr.ban(banned_addr.as_bannable(), ban_duration);
 
     let peer_mgr_join_handle = logging::spawn_in_current_span(async move {
         let mut peer_mgr = peer_mgr;
diff --git a/p2p/src/peer_manager/tests/discouragement.rs b/p2p/src/peer_manager/tests/discouragement.rs
index 06f9903012..80fbdd5863 100644
--- a/p2p/src/peer_manager/tests/discouragement.rs
+++ b/p2p/src/peer_manager/tests/discouragement.rs
@@ -41,7 +41,7 @@ use crate::{
         MAX_ADDR_RATE_PER_SECOND,
     },
     testing_utils::{
-        test_p2p_config, test_p2p_config_with_ban_config, test_p2p_config_with_peer_mgr_config,
+        test_p2p_config_with_ban_config, test_p2p_config_with_peer_mgr_config,
         test_peer_mgr_config_with_no_auto_outbound_connections, TestAddressMaker,
         TestTransportMaker, TestTransportTcp,
     },
@@ -52,7 +52,7 @@ use test_utils::random::{make_seedable_rng, Seed};
 
 // Check that a peer is discouraged once the threshold is reached.
 // Also check that
-// 1) it's NOT disconnected when becoming discouraged;
+// 1) it's disconnected when becoming discouraged;
 // 2) it's no longer discouraged once the duration has expired.
 #[tracing::instrument(skip(seed))]
 #[rstest]
@@ -66,8 +66,6 @@ async fn discourage_connected_peer(#[case] seed: Seed) {
     let ban_config = BanConfig {
         discouragement_threshold: 100.into(),
         discouragement_duration: Duration::from_secs(60 * 60).into(),
-        ban_threshold: 1000.into(),
-        ban_duration: Duration::from_secs(60 * 60 * 10).into(),
     };
     let p2p_config = Arc::new(test_p2p_config_with_ban_config(ban_config.clone()));
 
@@ -134,8 +132,9 @@ async fn discourage_connected_peer(#[case] seed: Seed) {
     .await;
     assert!(is_discouraged);
 
-    // No disconnection should happen
-    expect_no_recv!(cmd_receiver);
+    // The discouraged peer should be disconnected.
+    let cmd = expect_recv!(cmd_receiver);
+    assert_eq!(cmd, Command::Disconnect { peer_id });
 
     wait_for_no_recv(&mut peer_mgr_notification_receiver).await;
 
@@ -156,17 +155,40 @@ async fn discourage_connected_peer(#[case] seed: Seed) {
     let _peer_mgr = peer_mgr_join_handle.await.unwrap();
 }
 
-// Check that an incoming connection from a discouraged peer is NOT rejected.
+// Check that an incoming connection from a discouraged peer is NOT rejected if
+// max_inbound_connections is not reached yet.
 #[tracing::instrument(skip(seed))]
 #[rstest]
 #[trace]
 #[case(Seed::from_entropy())]
 #[tokio::test]
-async fn dont_reject_incoming_connection_from_discouraged_peer(#[case] seed: Seed) {
+async fn dont_reject_incoming_connection_from_discouraged_peer_if_limit_not_reached(
+    #[case] seed: Seed,
+) {
     let mut rng = make_seedable_rng(seed);
 
     let chain_config = Arc::new(config::create_unit_test_config());
-    let p2p_config = Arc::new(test_p2p_config());
+    let p2p_config = Arc::new(test_p2p_config_with_peer_mgr_config(PeerManagerConfig {
+        max_inbound_connections: 1.into(),
+
+        preserved_inbound_count_address_group: Default::default(),
+        preserved_inbound_count_ping: Default::default(),
+        preserved_inbound_count_new_blocks: Default::default(),
+        preserved_inbound_count_new_transactions: Default::default(),
+        outbound_block_relay_count: Default::default(),
+        outbound_block_relay_extra_count: Default::default(),
+        outbound_full_relay_count: Default::default(),
+        outbound_full_relay_extra_count: Default::default(),
+        outbound_block_relay_connection_min_age: Default::default(),
+        outbound_full_relay_connection_min_age: Default::default(),
+        stale_tip_time_diff: Default::default(),
+        main_loop_tick_interval: Default::default(),
+        enable_feeler_connections: Default::default(),
+        feeler_connections_interval: Default::default(),
+        force_dns_query_if_no_global_addresses_known: Default::default(),
+        allow_same_ip_connections: Default::default(),
+        peerdb_config: Default::default(),
+    }));
 
     let time_getter = P2pBasicTestTimeGetter::new();
     let bind_addr = TestTransportTcp::make_address();
@@ -205,6 +227,125 @@ async fn dont_reject_incoming_connection_from_discouraged_peer(#[case] seed: See
     let _peer_mgr = peer_mgr_join_handle.await.unwrap();
 }
 
+// Check that an incoming connection from a discouraged peer is rejected if max_inbound_connections
+// is already reached, even if there are peers eligible for eviction.
+#[tracing::instrument(skip(seed))]
+#[rstest]
+#[trace]
+#[case(Seed::from_entropy())]
+#[tokio::test]
+async fn reject_incoming_connection_from_discouraged_peer_if_limit_reached(#[case] seed: Seed) {
+    let mut rng = make_seedable_rng(seed);
+
+    let chain_config = Arc::new(config::create_unit_test_config());
+    let p2p_config = Arc::new(test_p2p_config_with_peer_mgr_config(PeerManagerConfig {
+        max_inbound_connections: 1.into(),
+
+        // Allow evicting any inbound peer.
+        preserved_inbound_count_address_group: 0.into(),
+        preserved_inbound_count_ping: 0.into(),
+        preserved_inbound_count_new_blocks: 0.into(),
+        preserved_inbound_count_new_transactions: 0.into(),
+
+        outbound_block_relay_count: Default::default(),
+        outbound_block_relay_extra_count: Default::default(),
+        outbound_full_relay_count: Default::default(),
+        outbound_full_relay_extra_count: Default::default(),
+        outbound_block_relay_connection_min_age: Default::default(),
+        outbound_full_relay_connection_min_age: Default::default(),
+        stale_tip_time_diff: Default::default(),
+        main_loop_tick_interval: Default::default(),
+        enable_feeler_connections: Default::default(),
+        feeler_connections_interval: Default::default(),
+        force_dns_query_if_no_global_addresses_known: Default::default(),
+        allow_same_ip_connections: Default::default(),
+        peerdb_config: Default::default(),
+    }));
+
+    let time_getter = P2pBasicTestTimeGetter::new();
+    let bind_addr = TestTransportTcp::make_address();
+
+    let (mut peer_mgr, conn_event_sender, peer_mgr_event_sender, mut cmd_receiver, _) =
+        make_standalone_peer_manager(
+            Arc::clone(&chain_config),
+            Arc::clone(&p2p_config),
+            vec![bind_addr],
+            time_getter.get_time_getter(),
+        );
+
+    let peer_addrs = make_non_colliding_addresses_for_peer_db_in_distinct_addr_groups(
+        &peer_mgr.peerdb,
+        3,
+        &mut rng,
+    );
+    let [discouraged_addr, normal_addr1, normal_addr2]: [_; 3] = peer_addrs.try_into().unwrap();
+
+    peer_mgr.discourage(discouraged_addr.as_bannable());
+
+    let peer_mgr_join_handle = logging::spawn_in_current_span(async move {
+        let mut peer_mgr = peer_mgr;
+        let _ = peer_mgr.run_internal(None).await;
+        peer_mgr
+    });
+
+    // Connection from a normal peer is accepted.
+    let normal_peer1_id = inbound_block_relay_peer_accepted_by_backend(
+        &conn_event_sender,
+        normal_addr1,
+        bind_addr,
+        &chain_config,
+    );
+    let cmd = expect_recv!(cmd_receiver);
+    assert_eq!(
+        cmd,
+        Command::Accept {
+            peer_id: normal_peer1_id
+        }
+    );
+
+    // Connection from the discouraged peer is rejected, because the limit is reached.
+    let discouraged_peer_id = inbound_block_relay_peer_accepted_by_backend(
+        &conn_event_sender,
+        discouraged_addr,
+        bind_addr,
+        &chain_config,
+    );
+    let cmd = expect_recv!(cmd_receiver);
+    assert_eq!(
+        cmd,
+        Command::Disconnect {
+            peer_id: discouraged_peer_id
+        }
+    );
+
+    // The previous normal peer gets evicted and the connection from another normal one is accepted.
+    let normal_peer2_id = inbound_block_relay_peer_accepted_by_backend(
+        &conn_event_sender,
+        normal_addr2,
+        bind_addr,
+        &chain_config,
+    );
+    let cmd = expect_recv!(cmd_receiver);
+    assert_eq!(
+        cmd,
+        Command::Disconnect {
+            peer_id: normal_peer1_id
+        }
+    );
+    let cmd = expect_recv!(cmd_receiver);
+    assert_eq!(
+        cmd,
+        Command::Accept {
+            peer_id: normal_peer2_id
+        }
+    );
+
+    drop(conn_event_sender);
+    drop(peer_mgr_event_sender);
+
+    let _peer_mgr = peer_mgr_join_handle.await.unwrap();
+}
+
 // Check that outgoing connections to discouraged peers are not established.
 #[tracing::instrument(skip(seed))]
 #[rstest]
diff --git a/p2p/src/peer_manager/tests/utils.rs b/p2p/src/peer_manager/tests/utils.rs
index e827e67ac7..acaf821398 100644
--- a/p2p/src/peer_manager/tests/utils.rs
+++ b/p2p/src/peer_manager/tests/utils.rs
@@ -21,8 +21,8 @@ use tokio::sync::mpsc;
 
 use p2p_test_utils::{wait_for_recv, P2pBasicTestTimeGetter};
 use p2p_types::{
-    bannable_address::BannableAddress, ip_or_socket_address::IpOrSocketAddress, services::Service, socket_address::SocketAddress,
-    PeerId,
+    bannable_address::BannableAddress, ip_or_socket_address::IpOrSocketAddress, services::Service,
+    socket_address::SocketAddress, PeerId,
 };
 use test_utils::assert_matches_return_val;
 
@@ -158,7 +158,7 @@ pub fn inbound_full_relay_peer_accepted_by_backend(
         .send(ConnectivityEvent::InboundAccepted {
             peer_address,
             bind_address,
-            peer_info: make_full_relay_peer_info(peer_id, &chain_config),
+            peer_info: make_full_relay_peer_info(peer_id, chain_config),
             node_address_as_seen_by_peer: None,
         })
         .unwrap();
@@ -178,7 +178,7 @@ pub fn outbound_block_relay_peer_accepted_by_backend(
         .send(ConnectivityEvent::OutboundAccepted {
             peer_address,
             bind_address,
-            peer_info: make_block_relay_peer_info(peer_id, &chain_config),
+            peer_info: make_block_relay_peer_info(peer_id, chain_config),
             node_address_as_seen_by_peer: None,
         })
         .unwrap();
@@ -206,15 +206,6 @@ pub fn outbound_full_relay_peer_accepted_by_backend(
     peer_id
 }
 
-/// Send a ConnectivityEvent simulating a PeerManagerMessage being received from the backend.
-pub fn peer_mgr_message_received_from_backend(
-    conn_event_sender: &mpsc::UnboundedSender<ConnectivityEvent>,
-    peer_id: PeerId,
-    message: PeerManagerMessage,
-) {
-    conn_event_sender.send(ConnectivityEvent::Message { peer_id, message }).unwrap();
-}
-
 pub async fn wait_for_heartbeat(
     peer_mgr_notification_receiver: &mut mpsc::UnboundedReceiver<PeerManagerNotification>,
 ) {
@@ -304,11 +295,12 @@ pub async fn adjust_peer_score(
 pub async fn ban_peer_manually(
     peer_mgr_event_sender: &mpsc::UnboundedSender<PeerManagerEvent>,
     peer_addr: BannableAddress,
+    duration: Duration,
 ) {
     let (result_sender, result_receiver) = oneshot_nofail::channel();
 
     peer_mgr_event_sender
-        .send(PeerManagerEvent::Ban(peer_addr, result_sender))
+        .send(PeerManagerEvent::Ban(peer_addr, duration, result_sender))
         .unwrap();
 
     result_receiver.await.unwrap().unwrap();
diff --git a/p2p/src/peer_manager/tests/whitelist.rs b/p2p/src/peer_manager/tests/whitelist.rs
index 7549b478b7..cea3a528b8 100644
--- a/p2p/src/peer_manager/tests/whitelist.rs
+++ b/p2p/src/peer_manager/tests/whitelist.rs
@@ -322,7 +322,11 @@ fn manual_ban_overrides_whitelisting() {
     assert!(pm.is_whitelisted_node(PeerRole::Inbound, &address_1));
 
     let (ban_sender, mut ban_receiver) = oneshot_nofail::channel();
-    pm.handle_control_event(PeerManagerEvent::Ban(address_1.as_bannable(), ban_sender));
+    pm.handle_control_event(PeerManagerEvent::Ban(
+        address_1.as_bannable(),
+        Duration::from_secs(60 * 60),
+        ban_sender,
+    ));
     ban_receiver.try_recv().unwrap().unwrap();
 
     // Peer is disconnected by the peer manager
diff --git a/p2p/src/peer_manager_event.rs b/p2p/src/peer_manager_event.rs
index 296cf321c1..697ce6d4fa 100644
--- a/p2p/src/peer_manager_event.rs
+++ b/p2p/src/peer_manager_event.rs
@@ -13,9 +13,11 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use std::time::Duration;
+
 use common::{
     chain::{Block, Transaction},
-    primitives::Id,
+    primitives::{time::Time, Id},
 };
 use p2p_types::{
     bannable_address::BannableAddress, ip_or_socket_address::IpOrSocketAddress,
@@ -61,7 +63,7 @@ pub enum PeerManagerEvent {
 
     /// Increases the ban score of a peer by the given amount.
     ///
-    /// The peer is discouraged or banned if the new score exceeds the corresponding threshold.
+    /// The peer is discouraged if the new score exceeds the corresponding threshold.
     AdjustPeerScore(PeerId, u32, oneshot_nofail::Sender<crate::Result<()>>),
 
     /// New tip block received.
@@ -95,14 +97,20 @@ pub enum PeerManagerEvent {
         new_status: PeerBlockSyncStatus,
     },
 
+    GetReserved(oneshot_nofail::Sender<Vec<SocketAddress>>),
     AddReserved(IpOrSocketAddress, oneshot_nofail::Sender<crate::Result<()>>),
-
     RemoveReserved(IpOrSocketAddress, oneshot_nofail::Sender<crate::Result<()>>),
 
-    ListBanned(oneshot_nofail::Sender<Vec<BannableAddress>>),
-    Ban(BannableAddress, oneshot_nofail::Sender<crate::Result<()>>),
+    ListBanned(oneshot_nofail::Sender<Vec<(BannableAddress, Time)>>),
+    Ban(
+        BannableAddress,
+        Duration,
+        oneshot_nofail::Sender<crate::Result<()>>,
+    ),
     Unban(BannableAddress, oneshot_nofail::Sender<crate::Result<()>>),
 
+    ListDiscouraged(oneshot_nofail::Sender<Vec<(BannableAddress, Time)>>),
+
     GenericQuery(Box<dyn PeerManagerQueryFunc>),
     #[cfg(test)]
     GenericMut(Box<dyn PeerManagerMutFunc>),
diff --git a/p2p/src/rpc.rs b/p2p/src/rpc.rs
index 011e55b48f..9f8818e987 100644
--- a/p2p/src/rpc.rs
+++ b/p2p/src/rpc.rs
@@ -13,7 +13,9 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use common::chain::SignedTransaction;
+use std::time::Duration;
+
+use common::{chain::SignedTransaction, primitives::time::Time};
 use mempool::tx_options::TxOptionsOverrides;
 use p2p_types::{
     bannable_address::BannableAddress, ip_or_socket_address::IpOrSocketAddress,
@@ -36,14 +38,17 @@ trait P2pRpc {
     async fn disconnect(&self, peer_id: PeerId) -> RpcResult<()>;
 
     #[method(name = "list_banned")]
-    async fn list_banned(&self) -> RpcResult<Vec<BannableAddress>>;
+    async fn list_banned(&self) -> RpcResult<Vec<(BannableAddress, Time)>>;
 
     #[method(name = "ban")]
-    async fn ban(&self, address: BannableAddress) -> RpcResult<()>;
+    async fn ban(&self, address: BannableAddress, duration: Duration) -> RpcResult<()>;
 
     #[method(name = "unban")]
     async fn unban(&self, address: BannableAddress) -> RpcResult<()>;
 
+    #[method(name = "list_discouraged")]
+    async fn list_discouraged(&self) -> RpcResult<Vec<(BannableAddress, Time)>>;
+
     /// Get the number of peers
     #[method(name = "get_peer_count")]
     async fn get_peer_count(&self) -> RpcResult<usize>;
@@ -56,6 +61,10 @@ trait P2pRpc {
     #[method(name = "get_connected_peers")]
     async fn get_connected_peers(&self) -> RpcResult<Vec<ConnectedPeer>>;
 
+    /// Get addresses of reserved nodes.
+    #[method(name = "get_reserved_nodes")]
+    async fn get_reserved_nodes(&self) -> RpcResult<Vec<SocketAddress>>;
+
     /// Add the address to the reserved nodes list.
     /// The node will try to keep connections open to all reserved peers.
     #[method(name = "add_reserved_node")]
@@ -87,13 +96,13 @@ impl P2pRpcServer for super::P2pHandle {
         rpc::handle_result(res)
     }
 
-    async fn list_banned(&self) -> RpcResult<Vec<BannableAddress>> {
-        let res = self.call_async_mut(|this| this.list_banned()).await;
+    async fn list_banned(&self) -> RpcResult<Vec<(BannableAddress, Time)>> {
+        let res = self.call_async(|this| this.list_banned()).await;
         rpc::handle_result(res)
     }
 
-    async fn ban(&self, address: BannableAddress) -> RpcResult<()> {
-        let res = self.call_async_mut(move |this| this.ban(address)).await;
+    async fn ban(&self, address: BannableAddress, duration: Duration) -> RpcResult<()> {
+        let res = self.call_async_mut(move |this| this.ban(address, duration)).await;
         rpc::handle_result(res)
     }
 
@@ -102,6 +111,11 @@ impl P2pRpcServer for super::P2pHandle {
         rpc::handle_result(res)
     }
 
+    async fn list_discouraged(&self) -> RpcResult<Vec<(BannableAddress, Time)>> {
+        let res = self.call_async(|this| this.list_discouraged()).await;
+        rpc::handle_result(res)
+    }
+
     async fn get_peer_count(&self) -> RpcResult<usize> {
         let res = self.call_async(|this| this.get_peer_count()).await;
         rpc::handle_result(res)
@@ -117,6 +131,11 @@ impl P2pRpcServer for super::P2pHandle {
         rpc::handle_result(res)
     }
 
+    async fn get_reserved_nodes(&self) -> RpcResult<Vec<SocketAddress>> {
+        let res = self.call_async(|this| this.get_reserved_nodes()).await;
+        rpc::handle_result(res)
+    }
+
     async fn add_reserved_node(&self, addr: IpOrSocketAddress) -> RpcResult<()> {
         let res = self.call_async_mut(|this| this.add_reserved_node(addr)).await;
         rpc::handle_result(res)
diff --git a/p2p/src/sync/peer_v2/block_manager.rs b/p2p/src/sync/peer_v2/block_manager.rs
index cd529d0a46..929028f111 100644
--- a/p2p/src/sync/peer_v2/block_manager.rs
+++ b/p2p/src/sync/peer_v2/block_manager.rs
@@ -804,8 +804,8 @@ where
 
     /// Sends a block list request.
     ///
-    /// The number of blocks requested equals `P2pConfig::requested_blocks_limit`, the remaining
-    /// headers are stored in the peer context.
+    /// The number of blocks requested equals `ProtocolConfig::max_request_blocks_count`,
+    /// the remaining headers are stored in the peer context.
     fn request_blocks(&mut self, mut headers: Vec<SignedBlockHeader>) -> Result<()> {
         debug_assert!(self.incoming.pending_headers.is_empty());
         debug_assert!(self.incoming.requested_blocks.is_empty());
diff --git a/p2p/src/sync/tests/block_response.rs b/p2p/src/sync/tests/block_response.rs
index 6186b51151..6b890ca2e1 100644
--- a/p2p/src/sync/tests/block_response.rs
+++ b/p2p/src/sync/tests/block_response.rs
@@ -150,12 +150,9 @@ async fn block_responses_in_wrong_order(#[case] seed: Seed) {
         let chain_config = Arc::new(create_unit_test_config());
         let p2p_config = Arc::new(P2pConfig {
             ban_config: BanConfig {
-                // We want to count bannable errors in this test, but don't want a disconnect
+                // We want to count discourageable errors in this test, but don't want a disconnect
                 // to happen because of them.
-                ban_threshold: 1000.into(),
-
-                ban_duration: Default::default(),
-                discouragement_threshold: Default::default(),
+                discouragement_threshold: 1000.into(),
                 discouragement_duration: Default::default(),
             },
 
diff --git a/p2p/src/sync/tests/helpers/mod.rs b/p2p/src/sync/tests/helpers/mod.rs
index 55f7945380..93a805b558 100644
--- a/p2p/src/sync/tests/helpers/mod.rs
+++ b/p2p/src/sync/tests/helpers/mod.rs
@@ -13,7 +13,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::{collections::BTreeSet, panic, sync::Arc};
+use std::{collections::BTreeSet, panic, sync::Arc, time::Duration};
 
 use async_trait::async_trait;
 use logging::log;
@@ -351,11 +351,13 @@ impl TestNode {
                     | PeerManagerEvent::GetBindAddresses(_)
                     | PeerManagerEvent::GetConnectedPeers(_)
                     | PeerManagerEvent::AdjustPeerScore(_, _, _)
+                    | PeerManagerEvent::GetReserved(_)
                     | PeerManagerEvent::AddReserved(_, _)
                     | PeerManagerEvent::RemoveReserved(_, _)
                     | PeerManagerEvent::ListBanned(_)
-                    | PeerManagerEvent::Ban(_, _)
+                    | PeerManagerEvent::Ban(_, _, _)
                     | PeerManagerEvent::Unban(_, _)
+                    | PeerManagerEvent::ListDiscouraged(_)
                     | PeerManagerEvent::GenericQuery(_)
                     | PeerManagerEvent::GenericMut(_) => {
                         panic!("Unexpected peer manager event: {peer_event:?}");
@@ -621,11 +623,13 @@ pub enum PeerManagerEventDesc {
         // values must be easy to predict. Currently, PeerBlockSyncStatus only contains a Time
         // value, which may be hard to predict, depending on the test.
     },
+    GetReserved,
     AddReserved(IpOrSocketAddress),
     RemoveReserved(IpOrSocketAddress),
     ListBanned,
-    Ban(BannableAddress),
+    Ban(BannableAddress, Duration),
     Unban(BannableAddress),
+    ListDiscouraged,
     GenericQuery,
     GenericMut,
 }
@@ -665,6 +669,7 @@ impl From<&PeerManagerEvent> for PeerManagerEventDesc {
                 peer_id,
                 new_status: _,
             } => PeerManagerEventDesc::PeerBlockSyncStatusUpdate { peer_id: *peer_id },
+            PeerManagerEvent::GetReserved(_) => PeerManagerEventDesc::GetReserved,
             PeerManagerEvent::AddReserved(addr, _) => {
                 PeerManagerEventDesc::AddReserved(addr.clone())
             }
@@ -672,8 +677,9 @@ impl From<&PeerManagerEvent> for PeerManagerEventDesc {
                 PeerManagerEventDesc::RemoveReserved(addr.clone())
             }
             PeerManagerEvent::ListBanned(_) => PeerManagerEventDesc::ListBanned,
-            PeerManagerEvent::Ban(addr, _) => PeerManagerEventDesc::Ban(*addr),
+            PeerManagerEvent::Ban(addr, duration, _) => PeerManagerEventDesc::Ban(*addr, *duration),
             PeerManagerEvent::Unban(addr, _) => PeerManagerEventDesc::Unban(*addr),
+            PeerManagerEvent::ListDiscouraged(_) => PeerManagerEventDesc::ListDiscouraged,
             PeerManagerEvent::GenericQuery(_) => PeerManagerEventDesc::GenericQuery,
             PeerManagerEvent::GenericMut(_) => PeerManagerEventDesc::GenericMut,
         }
diff --git a/p2p/src/sync/tests/helpers/test_node_group.rs b/p2p/src/sync/tests/helpers/test_node_group.rs
index d9aa30338e..a1c3bf09db 100644
--- a/p2p/src/sync/tests/helpers/test_node_group.rs
+++ b/p2p/src/sync/tests/helpers/test_node_group.rs
@@ -317,11 +317,13 @@ impl TestNodeGroup {
                         | PeerManagerEvent::GetBindAddresses(_)
                         | PeerManagerEvent::GetConnectedPeers(_)
                         | PeerManagerEvent::AdjustPeerScore(_, _, _)
+                        | PeerManagerEvent::GetReserved(_)
                         | PeerManagerEvent::AddReserved(_, _)
                         | PeerManagerEvent::RemoveReserved(_, _)
                         | PeerManagerEvent::ListBanned(_)
-                        | PeerManagerEvent::Ban(_, _)
+                        | PeerManagerEvent::Ban(_, _, _)
                         | PeerManagerEvent::Unban(_, _)
+                        | PeerManagerEvent::ListDiscouraged(_)
                         | PeerManagerEvent::GenericQuery(_)
                         | PeerManagerEvent::GenericMut(_) => {
                             panic!("Unexpected peer manager event: {peer_event:?}");
diff --git a/p2p/src/tests/correct_handshake.rs b/p2p/src/tests/correct_handshake.rs
index fad49e515e..5e6378819a 100644
--- a/p2p/src/tests/correct_handshake.rs
+++ b/p2p/src/tests/correct_handshake.rs
@@ -90,7 +90,7 @@ where
 
     // This is mainly needed to ensure that the corresponding events, if any, reach
     // peer manager before we end the test.
-    test_node.expect_no_banning().await;
+    test_node.expect_no_punishment().await;
 
     let test_node_remnants = test_node.join().await;
 
@@ -170,7 +170,7 @@ where
 
     // This is mainly needed to ensure that the corresponding events, if any, reach
     // peer manager before we end the test.
-    test_node.expect_no_banning().await;
+    test_node.expect_no_punishment().await;
 
     let test_node_remnants = test_node.join().await;
 
diff --git a/p2p/src/tests/helpers/test_node.rs b/p2p/src/tests/helpers/test_node.rs
index 8cd9105e08..b04afb05c8 100644
--- a/p2p/src/tests/helpers/test_node.rs
+++ b/p2p/src/tests/helpers/test_node.rs
@@ -266,7 +266,7 @@ where
         result_receiver
     }
 
-    pub async fn expect_no_banning(&mut self) {
+    pub async fn expect_no_punishment(&mut self) {
         time::timeout(SHORT_TIMEOUT, async {
             loop {
                 match self.peer_mgr_notification_receiver.recv().await.unwrap() {
@@ -277,6 +277,9 @@ where
                     | PeerManagerNotification::Ban { address: _ } => {
                         break;
                     }
+                    | PeerManagerNotification::Discourage { address: _ } => {
+                        break;
+                    }
                     _ => {}
                 }
             }
diff --git a/p2p/src/tests/incorrect_handshake.rs b/p2p/src/tests/incorrect_handshake.rs
index 978d5e184c..510862e49c 100644
--- a/p2p/src/tests/incorrect_handshake.rs
+++ b/p2p/src/tests/incorrect_handshake.rs
@@ -77,10 +77,17 @@ where
 
     // This is mainly needed to ensure that the corresponding events, if any, reach
     // peer manager before we end the test.
-    test_node.expect_no_banning().await;
+    test_node.expect_no_punishment().await;
 
-    // Note: no peer ban here, because peers are not banned during "manual outbound" connections.
+    // Note: no peer discouragement here, because peers are not discouraged during
+    // "manual outbound" connections.
     let test_node_remnants = test_node.join().await;
+    assert_eq!(
+        test_node_remnants.peer_mgr.peerdb().list_discouraged().count(),
+        0
+    );
+
+    // For consistency, check that we don't ban automatically.
     assert_eq!(
         test_node_remnants.peer_mgr.peerdb().list_banned().count(),
         0
@@ -145,7 +152,13 @@ where
     // The peer address should be banned.
     let test_node_remnants = test_node.join().await;
     // TODO: check the actual address instead of the count, same in other places.
-    assert!(test_node_remnants.peer_mgr.peerdb().list_banned().count() > 0);
+    assert!(test_node_remnants.peer_mgr.peerdb().list_discouraged().count() > 0);
+
+    // For consistency, check that we don't ban automatically.
+    assert_eq!(
+        test_node_remnants.peer_mgr.peerdb().list_banned().count(),
+        0
+    );
 }
 
 #[tracing::instrument]
diff --git a/wallet/src/wallet/mod.rs b/wallet/src/wallet/mod.rs
index c6f3edb720..15086a9463 100644
--- a/wallet/src/wallet/mod.rs
+++ b/wallet/src/wallet/mod.rs
@@ -79,7 +79,7 @@ pub const CURRENT_WALLET_VERSION: u32 = WALLET_VERSION_V5;
 pub enum WalletError {
     #[error("Wallet is not initialized")]
     WalletNotInitialized,
-    #[error("The wallet belongs to a different chain then the one specified")]
+    #[error("The wallet belongs to a different chain than the one specified")]
     DifferentChainType,
     #[error("Unsupported wallet version: {0}, max supported version of this software is {CURRENT_WALLET_VERSION}")]
     UnsupportedWalletVersion(u32),
diff --git a/wallet/wallet-cli-lib/Cargo.toml b/wallet/wallet-cli-lib/Cargo.toml
index b116aa6925..d3cff89c4f 100644
--- a/wallet/wallet-cli-lib/Cargo.toml
+++ b/wallet/wallet-cli-lib/Cargo.toml
@@ -28,7 +28,9 @@ wallet-rpc-lib = { path = "../wallet-rpc-lib" }
 clap = { workspace = true, features = ["derive"] }
 crossterm.workspace = true
 directories.workspace = true
+humantime.workspace = true
 hex.workspace = true
+itertools.workspace = true
 reedline = { workspace = true, features = ["external_printer"] }
 serde_json.workspace = true
 shlex.workspace = true
diff --git a/wallet/wallet-cli-lib/src/commands/helper_types.rs b/wallet/wallet-cli-lib/src/commands/helper_types.rs
index ecd66b64dc..3884e10956 100644
--- a/wallet/wallet-cli-lib/src/commands/helper_types.rs
+++ b/wallet/wallet-cli-lib/src/commands/helper_types.rs
@@ -364,3 +364,20 @@ impl CliIsUnfreezable {
 pub enum CliForceReduce {
     IKnowWhatIAmDoing,
 }
+
+#[derive(Debug, Clone)]
+pub struct Duration(std::time::Duration);
+
+impl FromStr for Duration {
+    type Err = humantime::DurationError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(Duration(humantime::parse_duration(s)?))
+    }
+}
+
+impl From<Duration> for std::time::Duration {
+    fn from(value: Duration) -> Self {
+        value.0
+    }
+}
diff --git a/wallet/wallet-cli-lib/src/commands/mod.rs b/wallet/wallet-cli-lib/src/commands/mod.rs
index bad250500e..578edfb3fa 100644
--- a/wallet/wallet-cli-lib/src/commands/mod.rs
+++ b/wallet/wallet-cli-lib/src/commands/mod.rs
@@ -23,6 +23,8 @@ use std::{
 };
 
 use clap::Parser;
+use itertools::Itertools;
+
 use common::{
     address::Address,
     chain::{
@@ -531,14 +533,25 @@ pub enum WalletCommand {
     #[clap(name = "node-list-banned-peers")]
     ListBanned,
 
-    /// Ban address in the node
+    /// Ban an address in the node for the specified duration
     #[clap(name = "node-ban-peer-address")]
-    Ban { address: BannableAddress },
+    Ban {
+        /// IP address to ban.
+        address: BannableAddress,
+        /// Duration of the ban, e.g. 1M (1 month) or "1y 3M 10d 6h 30m 45s"
+        /// (1 year 3 months 10 days 6 hours 30 minutes 45 seconds).
+        #[arg(value_parser = clap::value_parser!(helper_types::Duration))]
+        duration: helper_types::Duration,
+    },
 
     /// Unban address in the node
     #[clap(name = "node-unban-peer-address")]
     Unban { address: BannableAddress },
 
+    /// List discouraged addresses/peers in the node
+    #[clap(name = "node-list-discouraged-peers")]
+    ListDiscouraged,
+
     /// Get the number of connected peer in the node
     #[clap(name = "node-peer-count")]
     PeerCount,
@@ -551,6 +564,10 @@ pub enum WalletCommand {
     #[clap(name = "node-list-connected-peers-json")]
     ConnectedPeersJson,
 
+    /// Get reserved peers in the node
+    #[clap(name = "node-list-reserved-peers")]
+    ReservedPeers,
+
     /// Add a reserved peer in the node
     #[clap(name = "node-add-reserved-peer")]
     AddReservedPeer { address: IpOrSocketAddress },
@@ -1117,7 +1134,7 @@ where
                 Ok(ConsoleCommand::Print(format!(
                     "{} ({})",
                     timestamp,
-                    timestamp.into_time().as_standard_printable_time()
+                    timestamp.into_time()
                 )))
             }
 
@@ -1732,10 +1749,16 @@ where
 
             WalletCommand::ListBanned => {
                 let list = self.wallet_rpc.list_banned().await?;
-                Ok(ConsoleCommand::Print(format!("{list:#?}")))
+
+                let msg = list
+                    .iter()
+                    .map(|(addr, banned_until)| format!("{addr} (banned until {banned_until})"))
+                    .join("\n");
+
+                Ok(ConsoleCommand::Print(msg))
             }
-            WalletCommand::Ban { address } => {
-                self.wallet_rpc.ban_address(address).await?;
+            WalletCommand::Ban { address, duration } => {
+                self.wallet_rpc.ban_address(address, duration.into()).await?;
                 Ok(ConsoleCommand::Print("Success".to_owned()))
             }
             WalletCommand::Unban { address } => {
@@ -1743,6 +1766,19 @@ where
                 Ok(ConsoleCommand::Print("Success".to_owned()))
             }
 
+            WalletCommand::ListDiscouraged => {
+                let list = self.wallet_rpc.list_discouraged().await?;
+
+                let msg = list
+                    .iter()
+                    .map(|(addr, discouraged_until)| {
+                        format!("{addr} (discouraged until {discouraged_until})")
+                    })
+                    .join("\n");
+
+                Ok(ConsoleCommand::Print(msg))
+            }
+
             WalletCommand::PeerCount => {
                 let peer_count = self.wallet_rpc.peer_count().await?;
                 Ok(ConsoleCommand::Print(peer_count.to_string()))
@@ -1756,6 +1792,10 @@ where
                 let peers_json = serde_json::to_string(&peers)?;
                 Ok(ConsoleCommand::Print(peers_json))
             }
+            WalletCommand::ReservedPeers => {
+                let peers = self.wallet_rpc.reserved_peers().await?;
+                Ok(ConsoleCommand::Print(format!("{peers:#?}")))
+            }
             WalletCommand::AddReservedPeer { address } => {
                 self.wallet_rpc.add_reserved_peer(address).await?;
                 Ok(ConsoleCommand::Print("Success".to_owned()))
diff --git a/wallet/wallet-controller/src/sync/tests/mod.rs b/wallet/wallet-controller/src/sync/tests/mod.rs
index 4b680cd082..32eb0a42dc 100644
--- a/wallet/wallet-controller/src/sync/tests/mod.rs
+++ b/wallet/wallet-controller/src/sync/tests/mod.rs
@@ -25,7 +25,7 @@ use common::{
         tokens::{RPCTokenInfo, TokenId},
         DelegationId, PoolId, SignedTransaction, Transaction,
     },
-    primitives::Amount,
+    primitives::{time::Time, Amount},
 };
 use consensus::GenerateBlockInputData;
 use crypto::{
@@ -40,7 +40,10 @@ use node_comm::{
     node_traits::{ConnectedPeer, PeerId},
     rpc_client::NodeRpcError,
 };
-use p2p_types::{bannable_address::BannableAddress, ip_or_socket_address::IpOrSocketAddress};
+use p2p_types::{
+    bannable_address::BannableAddress, ip_or_socket_address::IpOrSocketAddress,
+    socket_address::SocketAddress,
+};
 use rstest::rstest;
 use test_utils::random::{make_seedable_rng, Seed};
 use tokio::sync::mpsc;
@@ -326,21 +329,31 @@ impl NodeInterface for MockNode {
     async fn p2p_disconnect(&self, _peer_id: PeerId) -> Result<(), Self::Error> {
         unreachable!()
     }
-    async fn p2p_list_banned(&self) -> Result<Vec<BannableAddress>, Self::Error> {
+    async fn p2p_list_banned(&self) -> Result<Vec<(BannableAddress, Time)>, Self::Error> {
         unreachable!()
     }
-    async fn p2p_ban(&self, _address: BannableAddress) -> Result<(), Self::Error> {
+    async fn p2p_ban(
+        &self,
+        _address: BannableAddress,
+        _duration: Duration,
+    ) -> Result<(), Self::Error> {
         unreachable!()
     }
     async fn p2p_unban(&self, _address: BannableAddress) -> Result<(), Self::Error> {
         unreachable!()
     }
+    async fn p2p_list_discouraged(&self) -> Result<Vec<(BannableAddress, Time)>, Self::Error> {
+        unreachable!()
+    }
     async fn p2p_get_peer_count(&self) -> Result<usize, Self::Error> {
         unreachable!()
     }
     async fn p2p_get_connected_peers(&self) -> Result<Vec<ConnectedPeer>, Self::Error> {
         unreachable!()
     }
+    async fn p2p_get_reserved_nodes(&self) -> Result<Vec<SocketAddress>, Self::Error> {
+        unreachable!()
+    }
     async fn p2p_add_reserved_node(&self, _address: IpOrSocketAddress) -> Result<(), Self::Error> {
         unreachable!()
     }
diff --git a/wallet/wallet-node-client/src/handles_client/mod.rs b/wallet/wallet-node-client/src/handles_client/mod.rs
index 14ce1bd607..73ade2f851 100644
--- a/wallet/wallet-node-client/src/handles_client/mod.rs
+++ b/wallet/wallet-node-client/src/handles_client/mod.rs
@@ -13,7 +13,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::num::NonZeroUsize;
+use std::{num::NonZeroUsize, time::Duration};
 
 use blockprod::{BlockProductionError, BlockProductionHandle};
 use chainstate::{BlockSource, ChainInfo, ChainstateError, ChainstateHandle};
@@ -22,7 +22,7 @@ use common::{
         tokens::{RPCTokenInfo, TokenId},
         Block, DelegationId, GenBlock, PoolId, SignedTransaction, Transaction,
     },
-    primitives::{Amount, BlockHeight, Id},
+    primitives::{time::Time, Amount, BlockHeight, Id},
 };
 use consensus::GenerateBlockInputData;
 use crypto::ephemeral_e2e::EndToEndPublicKey;
@@ -33,7 +33,8 @@ use p2p::{
     error::P2pError,
     interface::types::ConnectedPeer,
     types::{
-        bannable_address::BannableAddress, ip_or_socket_address::IpOrSocketAddress, peer_id::PeerId,
+        bannable_address::BannableAddress, ip_or_socket_address::IpOrSocketAddress,
+        peer_id::PeerId, socket_address::SocketAddress,
     },
     P2pHandle,
 };
@@ -289,16 +290,20 @@ impl NodeInterface for WalletHandlesClient {
         Ok(())
     }
     async fn p2p_get_peer_count(&self) -> Result<usize, Self::Error> {
-        let count = self.p2p.call_async_mut(move |this| this.get_peer_count()).await??;
+        let count = self.p2p.call_async(move |this| this.get_peer_count()).await??;
         Ok(count)
     }
 
-    async fn p2p_list_banned(&self) -> Result<Vec<BannableAddress>, Self::Error> {
-        let list = self.p2p.call_async_mut(move |this| this.list_banned()).await??;
+    async fn p2p_list_banned(&self) -> Result<Vec<(BannableAddress, Time)>, Self::Error> {
+        let list = self.p2p.call_async(move |this| this.list_banned()).await??;
         Ok(list)
     }
-    async fn p2p_ban(&self, address: BannableAddress) -> Result<(), Self::Error> {
-        self.p2p.call_async_mut(move |this| this.ban(address)).await??;
+    async fn p2p_ban(
+        &self,
+        address: BannableAddress,
+        duration: Duration,
+    ) -> Result<(), Self::Error> {
+        self.p2p.call_async_mut(move |this| this.ban(address, duration)).await??;
         Ok(())
     }
     async fn p2p_unban(&self, address: BannableAddress) -> Result<(), Self::Error> {
@@ -306,8 +311,17 @@ impl NodeInterface for WalletHandlesClient {
         Ok(())
     }
 
+    async fn p2p_list_discouraged(&self) -> Result<Vec<(BannableAddress, Time)>, Self::Error> {
+        let list = self.p2p.call_async(move |this| this.list_discouraged()).await??;
+        Ok(list)
+    }
+
     async fn p2p_get_connected_peers(&self) -> Result<Vec<ConnectedPeer>, Self::Error> {
-        let peers = self.p2p.call_async_mut(move |this| this.get_connected_peers()).await??;
+        let peers = self.p2p.call_async(move |this| this.get_connected_peers()).await??;
+        Ok(peers)
+    }
+    async fn p2p_get_reserved_nodes(&self) -> Result<Vec<SocketAddress>, Self::Error> {
+        let peers = self.p2p.call_async(move |this| this.get_reserved_nodes()).await??;
         Ok(peers)
     }
     async fn p2p_add_reserved_node(&self, address: IpOrSocketAddress) -> Result<(), Self::Error> {
diff --git a/wallet/wallet-node-client/src/node_traits.rs b/wallet/wallet-node-client/src/node_traits.rs
index 1315abf316..abbbb0ff83 100644
--- a/wallet/wallet-node-client/src/node_traits.rs
+++ b/wallet/wallet-node-client/src/node_traits.rs
@@ -13,6 +13,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use std::time::Duration;
+
 use chainstate::ChainInfo;
 use common::{
     chain::{
@@ -20,13 +22,16 @@ use common::{
         Block, DelegationId, GenBlock, PoolId, SignedTransaction, Transaction, TxOutput,
         UtxoOutPoint,
     },
-    primitives::{Amount, BlockHeight, Id},
+    primitives::{time::Time, Amount, BlockHeight, Id},
 };
 
 use consensus::GenerateBlockInputData;
 use crypto::ephemeral_e2e::EndToEndPublicKey;
 use mempool::{tx_accumulator::PackingStrategy, tx_options::TxOptionsOverrides, FeeRate};
-use p2p::types::{bannable_address::BannableAddress, ip_or_socket_address::IpOrSocketAddress};
+use p2p::types::{
+    bannable_address::BannableAddress, ip_or_socket_address::IpOrSocketAddress,
+    socket_address::SocketAddress,
+};
 pub use p2p::{interface::types::ConnectedPeer, types::peer_id::PeerId};
 
 #[async_trait::async_trait]
@@ -87,11 +92,17 @@ pub trait NodeInterface {
 
     async fn p2p_connect(&self, address: IpOrSocketAddress) -> Result<(), Self::Error>;
     async fn p2p_disconnect(&self, peer_id: PeerId) -> Result<(), Self::Error>;
-    async fn p2p_list_banned(&self) -> Result<Vec<BannableAddress>, Self::Error>;
-    async fn p2p_ban(&self, address: BannableAddress) -> Result<(), Self::Error>;
+    async fn p2p_list_banned(&self) -> Result<Vec<(BannableAddress, Time)>, Self::Error>;
+    async fn p2p_ban(
+        &self,
+        address: BannableAddress,
+        duration: Duration,
+    ) -> Result<(), Self::Error>;
     async fn p2p_unban(&self, address: BannableAddress) -> Result<(), Self::Error>;
+    async fn p2p_list_discouraged(&self) -> Result<Vec<(BannableAddress, Time)>, Self::Error>;
     async fn p2p_get_peer_count(&self) -> Result<usize, Self::Error>;
     async fn p2p_get_connected_peers(&self) -> Result<Vec<ConnectedPeer>, Self::Error>;
+    async fn p2p_get_reserved_nodes(&self) -> Result<Vec<SocketAddress>, Self::Error>;
     async fn p2p_add_reserved_node(&self, address: IpOrSocketAddress) -> Result<(), Self::Error>;
     async fn p2p_remove_reserved_node(&self, address: IpOrSocketAddress)
         -> Result<(), Self::Error>;
diff --git a/wallet/wallet-node-client/src/rpc_client/client_impl.rs b/wallet/wallet-node-client/src/rpc_client/client_impl.rs
index 64bfa3855c..cee1d0e4f5 100644
--- a/wallet/wallet-node-client/src/rpc_client/client_impl.rs
+++ b/wallet/wallet-node-client/src/rpc_client/client_impl.rs
@@ -13,6 +13,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use std::time::Duration;
+
 use blockprod::rpc::BlockProductionRpcClient;
 use chainstate::{rpc::ChainstateRpcClient, ChainInfo};
 use common::{
@@ -21,7 +23,7 @@ use common::{
         Block, DelegationId, GenBlock, PoolId, SignedTransaction, Transaction, TxOutput,
         UtxoOutPoint,
     },
-    primitives::{Amount, BlockHeight, Id},
+    primitives::{time::Time, Amount, BlockHeight, Id},
 };
 use consensus::GenerateBlockInputData;
 use crypto::ephemeral_e2e::EndToEndPublicKey;
@@ -32,7 +34,8 @@ use p2p::{
     interface::types::ConnectedPeer,
     rpc::P2pRpcClient,
     types::{
-        bannable_address::BannableAddress, ip_or_socket_address::IpOrSocketAddress, peer_id::PeerId,
+        bannable_address::BannableAddress, ip_or_socket_address::IpOrSocketAddress,
+        peer_id::PeerId, socket_address::SocketAddress,
     },
 };
 use serialization::hex_encoded::HexEncoded;
@@ -220,13 +223,17 @@ impl NodeInterface for NodeRpcClient {
             .map_err(NodeRpcError::ResponseError)
     }
 
-    async fn p2p_list_banned(&self) -> Result<Vec<BannableAddress>, Self::Error> {
+    async fn p2p_list_banned(&self) -> Result<Vec<(BannableAddress, Time)>, Self::Error> {
         P2pRpcClient::list_banned(&self.http_client)
             .await
             .map_err(NodeRpcError::ResponseError)
     }
-    async fn p2p_ban(&self, address: BannableAddress) -> Result<(), Self::Error> {
-        P2pRpcClient::ban(&self.http_client, address)
+    async fn p2p_ban(
+        &self,
+        address: BannableAddress,
+        duration: Duration,
+    ) -> Result<(), Self::Error> {
+        P2pRpcClient::ban(&self.http_client, address, duration)
             .await
             .map_err(NodeRpcError::ResponseError)
     }
@@ -236,6 +243,12 @@ impl NodeInterface for NodeRpcClient {
             .map_err(NodeRpcError::ResponseError)
     }
 
+    async fn p2p_list_discouraged(&self) -> Result<Vec<(BannableAddress, Time)>, Self::Error> {
+        P2pRpcClient::list_discouraged(&self.http_client)
+            .await
+            .map_err(NodeRpcError::ResponseError)
+    }
+
     async fn p2p_get_peer_count(&self) -> Result<usize, Self::Error> {
         P2pRpcClient::get_peer_count(&self.http_client)
             .await
@@ -246,6 +259,12 @@ impl NodeInterface for NodeRpcClient {
             .await
             .map_err(NodeRpcError::ResponseError)
     }
+
+    async fn p2p_get_reserved_nodes(&self) -> Result<Vec<SocketAddress>, Self::Error> {
+        P2pRpcClient::get_reserved_nodes(&self.http_client)
+            .await
+            .map_err(NodeRpcError::ResponseError)
+    }
     async fn p2p_add_reserved_node(&self, address: IpOrSocketAddress) -> Result<(), Self::Error> {
         P2pRpcClient::add_reserved_node(&self.http_client, address)
             .await
diff --git a/wallet/wallet-node-client/src/rpc_client/cold_wallet_client.rs b/wallet/wallet-node-client/src/rpc_client/cold_wallet_client.rs
index d5a2119d08..5f7930570c 100644
--- a/wallet/wallet-node-client/src/rpc_client/cold_wallet_client.rs
+++ b/wallet/wallet-node-client/src/rpc_client/cold_wallet_client.rs
@@ -13,20 +13,25 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use std::time::Duration;
+
 use chainstate::ChainInfo;
 use common::{
     chain::{
         tokens::{RPCTokenInfo, TokenId},
         Block, DelegationId, GenBlock, PoolId, SignedTransaction, Transaction,
     },
-    primitives::{Amount, BlockHeight, Id},
+    primitives::{time::Time, Amount, BlockHeight, Id},
 };
 use consensus::GenerateBlockInputData;
 use crypto::ephemeral_e2e::EndToEndPublicKey;
 use mempool::{tx_accumulator::PackingStrategy, tx_options::TxOptionsOverrides, FeeRate};
 use p2p::{
     interface::types::ConnectedPeer,
-    types::{bannable_address::BannableAddress, ip_or_socket_address::IpOrSocketAddress, PeerId},
+    types::{
+        bannable_address::BannableAddress, ip_or_socket_address::IpOrSocketAddress,
+        socket_address::SocketAddress, PeerId,
+    },
 };
 
 use crate::node_traits::NodeInterface;
@@ -168,11 +173,15 @@ impl NodeInterface for ColdWalletClient {
         Err(ColdWalletRpcError::NotAvailable)
     }
 
-    async fn p2p_list_banned(&self) -> Result<Vec<BannableAddress>, Self::Error> {
+    async fn p2p_list_banned(&self) -> Result<Vec<(BannableAddress, Time)>, Self::Error> {
         Err(ColdWalletRpcError::NotAvailable)
     }
 
-    async fn p2p_ban(&self, _address: BannableAddress) -> Result<(), Self::Error> {
+    async fn p2p_ban(
+        &self,
+        _address: BannableAddress,
+        _duration: Duration,
+    ) -> Result<(), Self::Error> {
         Err(ColdWalletRpcError::NotAvailable)
     }
 
@@ -180,6 +189,10 @@ impl NodeInterface for ColdWalletClient {
         Err(ColdWalletRpcError::NotAvailable)
     }
 
+    async fn p2p_list_discouraged(&self) -> Result<Vec<(BannableAddress, Time)>, Self::Error> {
+        Err(ColdWalletRpcError::NotAvailable)
+    }
+
     async fn p2p_get_peer_count(&self) -> Result<usize, Self::Error> {
         Err(ColdWalletRpcError::NotAvailable)
     }
@@ -188,6 +201,10 @@ impl NodeInterface for ColdWalletClient {
         Err(ColdWalletRpcError::NotAvailable)
     }
 
+    async fn p2p_get_reserved_nodes(&self) -> Result<Vec<SocketAddress>, Self::Error> {
+        Err(ColdWalletRpcError::NotAvailable)
+    }
+
     async fn p2p_add_reserved_node(&self, _address: IpOrSocketAddress) -> Result<(), Self::Error> {
         Err(ColdWalletRpcError::NotAvailable)
     }
diff --git a/wallet/wallet-rpc-lib/src/rpc/interface.rs b/wallet/wallet-rpc-lib/src/rpc/interface.rs
index 05d97c62ef..e048e806dd 100644
--- a/wallet/wallet-rpc-lib/src/rpc/interface.rs
+++ b/wallet/wallet-rpc-lib/src/rpc/interface.rs
@@ -18,7 +18,7 @@ use common::{
     chain::{Block, GenBlock, SignedTransaction, Transaction},
     primitives::{BlockHeight, Id},
 };
-use p2p_types::bannable_address::BannableAddress;
+use p2p_types::{bannable_address::BannableAddress, socket_address::SocketAddress};
 use wallet_controller::{types::BlockInfo, ConnectedPeer};
 use wallet_types::with_locked::WithLocked;
 
@@ -321,20 +321,34 @@ trait WalletRpc {
     async fn disconnect_peer(&self, peer_id: u64) -> rpc::RpcResult<()>;
 
     #[method(name = "node_list_banned_peers")]
-    async fn list_banned(&self) -> rpc::RpcResult<Vec<BannableAddress>>;
+    async fn list_banned(
+        &self,
+    ) -> rpc::RpcResult<Vec<(BannableAddress, common::primitives::time::Time)>>;
 
     #[method(name = "node_ban_peer_address")]
-    async fn ban_address(&self, address: BannableAddress) -> rpc::RpcResult<()>;
+    async fn ban_address(
+        &self,
+        address: BannableAddress,
+        duration: std::time::Duration,
+    ) -> rpc::RpcResult<()>;
 
     #[method(name = "node_unban_peer_address")]
     async fn unban_address(&self, address: BannableAddress) -> rpc::RpcResult<()>;
 
+    #[method(name = "node_list_discouraged_peers")]
+    async fn list_discouraged(
+        &self,
+    ) -> rpc::RpcResult<Vec<(BannableAddress, common::primitives::time::Time)>>;
+
     #[method(name = "node-peer-count")]
     async fn peer_count(&self) -> rpc::RpcResult<usize>;
 
     #[method(name = "node_list_connected_peers")]
     async fn connected_peers(&self) -> rpc::RpcResult<Vec<ConnectedPeer>>;
 
+    #[method(name = "node_list_reserved_peers")]
+    async fn reserved_peers(&self) -> rpc::RpcResult<Vec<SocketAddress>>;
+
     #[method(name = "node_add_reserved_peer")]
     async fn add_reserved_peer(&self, address: String) -> rpc::RpcResult<()>;
 
diff --git a/wallet/wallet-rpc-lib/src/rpc/mod.rs b/wallet/wallet-rpc-lib/src/rpc/mod.rs
index cb24fc8f34..8d9064881d 100644
--- a/wallet/wallet-rpc-lib/src/rpc/mod.rs
+++ b/wallet/wallet-rpc-lib/src/rpc/mod.rs
@@ -22,10 +22,11 @@ use crypto::key::hdkd::u31::U31;
 use mempool::tx_accumulator::PackingStrategy;
 use mempool_types::tx_options::TxOptionsOverrides;
 use p2p_types::{
-    bannable_address::BannableAddress, ip_or_socket_address::IpOrSocketAddress, PeerId,
+    bannable_address::BannableAddress, ip_or_socket_address::IpOrSocketAddress,
+    socket_address::SocketAddress, PeerId,
 };
 use serialization::{hex_encoded::HexEncoded, Decode, DecodeAll};
-use std::{collections::BTreeMap, fmt::Debug, path::PathBuf, sync::Arc};
+use std::{collections::BTreeMap, fmt::Debug, path::PathBuf, sync::Arc, time::Duration};
 use utils::{ensure, shallow_clone::ShallowClone};
 use wallet::{
     account::{PartiallySignedTransaction, PoolData, TransactionToSign},
@@ -40,7 +41,8 @@ use common::{
         Transaction, TxOutput, UtxoOutPoint,
     },
     primitives::{
-        id::WithId, per_thousand::PerThousand, Amount, BlockHeight, DecimalAmount, Id, Idable,
+        id::WithId, per_thousand::PerThousand, time::Time, Amount, BlockHeight, DecimalAmount, Id,
+        Idable,
     },
 };
 pub use interface::WalletRpcServer;
@@ -1106,18 +1108,26 @@ impl<N: NodeInterface + Clone + Send + Sync + 'static> WalletRpc<N> {
         self.node.p2p_disconnect(peer_id).await.map_err(RpcError::RpcError)
     }
 
-    pub async fn list_banned(&self) -> WRpcResult<Vec<BannableAddress>, N> {
+    pub async fn list_banned(&self) -> WRpcResult<Vec<(BannableAddress, Time)>, N> {
         self.node.p2p_list_banned().await.map_err(RpcError::RpcError)
     }
 
-    pub async fn ban_address(&self, address: BannableAddress) -> WRpcResult<(), N> {
-        self.node.p2p_ban(address).await.map_err(RpcError::RpcError)
+    pub async fn ban_address(
+        &self,
+        address: BannableAddress,
+        duration: Duration,
+    ) -> WRpcResult<(), N> {
+        self.node.p2p_ban(address, duration).await.map_err(RpcError::RpcError)
     }
 
     pub async fn unban_address(&self, address: BannableAddress) -> WRpcResult<(), N> {
         self.node.p2p_unban(address).await.map_err(RpcError::RpcError)
     }
 
+    pub async fn list_discouraged(&self) -> WRpcResult<Vec<(BannableAddress, Time)>, N> {
+        self.node.p2p_list_discouraged().await.map_err(RpcError::RpcError)
+    }
+
     pub async fn peer_count(&self) -> WRpcResult<usize, N> {
         self.node.p2p_get_peer_count().await.map_err(RpcError::RpcError)
     }
@@ -1126,6 +1136,10 @@ impl<N: NodeInterface + Clone + Send + Sync + 'static> WalletRpc<N> {
         self.node.p2p_get_connected_peers().await.map_err(RpcError::RpcError)
     }
 
+    pub async fn reserved_peers(&self) -> WRpcResult<Vec<SocketAddress>, N> {
+        self.node.p2p_get_reserved_nodes().await.map_err(RpcError::RpcError)
+    }
+
     pub async fn add_reserved_peer(&self, address: IpOrSocketAddress) -> WRpcResult<(), N> {
         self.node.p2p_add_reserved_node(address).await.map_err(RpcError::RpcError)
     }
diff --git a/wallet/wallet-rpc-lib/src/rpc/server_impl.rs b/wallet/wallet-rpc-lib/src/rpc/server_impl.rs
index bfbe0f6fed..0cca8870f5 100644
--- a/wallet/wallet-rpc-lib/src/rpc/server_impl.rs
+++ b/wallet/wallet-rpc-lib/src/rpc/server_impl.rs
@@ -17,13 +17,14 @@ use chainstate::ChainInfo;
 use common::{
     address::dehexify::{dehexify_all_addresses, to_dehexified_json},
     chain::{tokens::IsTokenUnfreezable, Block, GenBlock, SignedTransaction, Transaction},
-    primitives::{BlockHeight, Id, Idable, H256},
+    primitives::{time::Time, BlockHeight, Id, Idable, H256},
 };
 use p2p_types::{
-    bannable_address::BannableAddress, ip_or_socket_address::IpOrSocketAddress, PeerId,
+    bannable_address::BannableAddress, ip_or_socket_address::IpOrSocketAddress,
+    socket_address::SocketAddress, PeerId,
 };
 use serialization::{hex::HexEncode, json_encoded::JsonEncoded};
-use std::{fmt::Debug, str::FromStr};
+use std::{fmt::Debug, str::FromStr, time::Duration};
 use wallet_controller::{
     types::BlockInfo, ConnectedPeer, ControllerConfig, NodeInterface, UtxoStates, UtxoTypes,
 };
@@ -587,18 +588,26 @@ impl<N: NodeInterface + Clone + Send + Sync + 'static + Debug> WalletRpcServer f
         rpc::handle_result(self.disconnect_peer(PeerId::from_u64(peer_id)).await)
     }
 
-    async fn list_banned(&self) -> rpc::RpcResult<Vec<BannableAddress>> {
+    async fn list_banned(&self) -> rpc::RpcResult<Vec<(BannableAddress, Time)>> {
         rpc::handle_result(self.list_banned().await)
     }
 
-    async fn ban_address(&self, address: BannableAddress) -> rpc::RpcResult<()> {
-        rpc::handle_result(self.ban_address(address).await)
+    async fn ban_address(
+        &self,
+        address: BannableAddress,
+        duration: Duration,
+    ) -> rpc::RpcResult<()> {
+        rpc::handle_result(self.ban_address(address, duration).await)
     }
 
     async fn unban_address(&self, address: BannableAddress) -> rpc::RpcResult<()> {
         rpc::handle_result(self.unban_address(address).await)
     }
 
+    async fn list_discouraged(&self) -> rpc::RpcResult<Vec<(BannableAddress, Time)>> {
+        rpc::handle_result(self.list_discouraged().await)
+    }
+
     async fn peer_count(&self) -> rpc::RpcResult<usize> {
         rpc::handle_result(self.peer_count().await)
     }
@@ -607,6 +616,10 @@ impl<N: NodeInterface + Clone + Send + Sync + 'static + Debug> WalletRpcServer f
         rpc::handle_result(self.connected_peers().await)
     }
 
+    async fn reserved_peers(&self) -> rpc::RpcResult<Vec<SocketAddress>> {
+        rpc::handle_result(self.reserved_peers().await)
+    }
+
     async fn add_reserved_peer(&self, address: String) -> rpc::RpcResult<()> {
         let address =
             IpOrSocketAddress::from_str(&address).map_err(|_| RpcError::<N>::InvalidIpAddress)?;