diff --git a/Cargo.lock b/Cargo.lock
index 31df58e8ec4..2f24420a86f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1924,6 +1924,15 @@ dependencies = [
  "allocator-api2",
 ]
 
+[[package]]
+name = "hashlink"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ba4ff7128dee98c7dc9794b6a411377e1404dba1c97deb8d1a55297bd25d8af"
+dependencies = [
+ "hashbrown 0.14.3",
+]
+
 [[package]]
 name = "heck"
 version = "0.4.1"
@@ -2875,6 +2884,7 @@ dependencies = [
  "futures",
  "futures-timer",
  "getrandom 0.2.15",
+ "hashlink",
  "hex",
  "hex_fmt",
  "libp2p-core",
diff --git a/Cargo.toml b/Cargo.toml
index c77768db311..e312f011a1e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -137,6 +137,7 @@ tracing = "0.1.37"
 tracing-subscriber = "0.3"
 unsigned-varint = { version = "0.8.0" }
 web-time = "1.1.0"
+hashlink = "0.9.0"
 
 [patch.crates-io]
 
diff --git a/protocols/gossipsub/Cargo.toml b/protocols/gossipsub/Cargo.toml
index c09286c8aa0..1926b321bd6 100644
--- a/protocols/gossipsub/Cargo.toml
+++ b/protocols/gossipsub/Cargo.toml
@@ -24,6 +24,7 @@ fnv = "1.0.7"
 futures = { workspace = true }
 futures-timer = "3.0.2"
 getrandom = "0.2.15"
+hashlink.workspace = true
 hex_fmt = "0.3.0"
 web-time = { workspace = true }
 libp2p-core = { workspace = true }
diff --git a/protocols/gossipsub/src/behaviour.rs b/protocols/gossipsub/src/behaviour.rs
index 954e87ee470..f58b2a35e27 100644
--- a/protocols/gossipsub/src/behaviour.rs
+++ b/protocols/gossipsub/src/behaviour.rs
@@ -30,6 +30,7 @@ use std::{
 
 use futures::FutureExt;
 use futures_timer::Delay;
+use hashlink::LinkedHashMap;
 use libp2p_core::{
     multiaddr::Protocol::{Ip4, Ip6},
     transport::PortUse,
@@ -63,8 +64,9 @@ use crate::{
     topic::{Hasher, Topic, TopicHash},
     transform::{DataTransform, IdentityTransform},
     types::{
-        ControlAction, Graft, IHave, IWant, Message, MessageAcceptance, MessageId, PeerConnections,
-        PeerInfo, PeerKind, Prune, RawMessage, RpcOut, Subscription, SubscriptionAction,
+        ControlAction, Graft, IDontWant, IHave, IWant, Message, MessageAcceptance, MessageId,
+        PeerConnections, PeerInfo, PeerKind, Prune, RawMessage, RpcOut, Subscription,
+        SubscriptionAction,
     },
     FailedMessages, PublishError, SubscriptionError, TopicScoreParams, ValidationError,
 };
@@ -72,6 +74,12 @@ use crate::{
 #[cfg(test)]
 mod tests;
 
+/// IDONTWANT cache capacity.
+const IDONTWANT_CAP: usize = 10_000;
+
+/// IDONTWANT timeout before removal.
+const IDONTWANT_TIMEOUT: Duration = Duration::new(3, 0);
+
 /// Determines if published messages should be signed or not.
 ///
 /// Without signing, a number of privacy preserving modes can be selected.
@@ -306,7 +314,7 @@ pub struct Behaviour<D = IdentityTransform, F = AllowAllSubscriptionFilter> {
 
     /// Stores optional peer score data together with thresholds, decay interval and gossip
     /// promises.
-    peer_score: Option<(PeerScore, PeerScoreThresholds, Delay, GossipPromises)>,
+    peer_score: Option<(PeerScore, PeerScoreThresholds, Delay)>,
 
     /// Counts the number of `IHAVE` received from each peer since the last heartbeat.
     count_received_ihave: HashMap<PeerId, usize>,
@@ -331,6 +339,9 @@ pub struct Behaviour<D = IdentityTransform, F = AllowAllSubscriptionFilter> {
 
     /// Tracks the numbers of failed messages per peer-id.
     failed_messages: HashMap<PeerId, FailedMessages>,
+
+    /// Tracks recently sent `IWANT` messages and checks if peers respond to them.
+    gossip_promises: GossipPromises,
 }
 
 impl<D, F> Behaviour<D, F>
@@ -464,6 +475,7 @@ where
             subscription_filter,
             data_transform,
             failed_messages: Default::default(),
+            gossip_promises: Default::default(),
         })
     }
 }
@@ -897,7 +909,7 @@ where
 
         let interval = Delay::new(params.decay_interval);
         let peer_score = PeerScore::new_with_message_delivery_time_callback(params, callback);
-        self.peer_score = Some((peer_score, threshold, interval, GossipPromises::default()));
+        self.peer_score = Some((peer_score, threshold, interval));
         Ok(())
     }
 
@@ -1161,7 +1173,7 @@ where
     }
 
     fn score_below_threshold_from_scores(
-        peer_score: &Option<(PeerScore, PeerScoreThresholds, Delay, GossipPromises)>,
+        peer_score: &Option<(PeerScore, PeerScoreThresholds, Delay)>,
         peer_id: &PeerId,
         threshold: impl Fn(&PeerScoreThresholds) -> f64,
     ) -> (bool, f64) {
@@ -1222,10 +1234,7 @@ where
                 return false;
             }
 
-            self.peer_score
-                .as_ref()
-                .map(|(_, _, _, promises)| !promises.contains(id))
-                .unwrap_or(true)
+            !self.gossip_promises.contains(id)
         };
 
         for (topic, ids) in ihave_msgs {
@@ -1272,13 +1281,11 @@ where
             iwant_ids_vec.truncate(iask);
             *iasked += iask;
 
-            if let Some((_, _, _, gossip_promises)) = &mut self.peer_score {
-                gossip_promises.add_promise(
-                    *peer_id,
-                    &iwant_ids_vec,
-                    Instant::now() + self.config.iwant_followup_time(),
-                );
-            }
+            self.gossip_promises.add_promise(
+                *peer_id,
+                &iwant_ids_vec,
+                Instant::now() + self.config.iwant_followup_time(),
+            );
             tracing::trace!(
                 peer=%peer_id,
                 "IHAVE: Asking for the following messages from peer: {:?}",
@@ -1642,14 +1649,15 @@ where
                 peer=%propagation_source,
                 "Rejecting message from blacklisted peer"
             );
-            if let Some((peer_score, .., gossip_promises)) = &mut self.peer_score {
+            self.gossip_promises
+                .reject_message(msg_id, &RejectReason::BlackListedPeer);
+            if let Some((peer_score, ..)) = &mut self.peer_score {
                 peer_score.reject_message(
                     propagation_source,
                     msg_id,
                     &raw_message.topic,
                     RejectReason::BlackListedPeer,
                 );
-                gossip_promises.reject_message(msg_id, &RejectReason::BlackListedPeer);
             }
             return false;
         }
@@ -1731,6 +1739,9 @@ where
         // Calculate the message id on the transformed data.
         let msg_id = self.config.message_id(&message);
 
+        // Broadcast IDONTWANT messages.
+        self.send_idontwant(&raw_message, &msg_id, propagation_source);
+
         // Check the validity of the message
         // Peers get penalized if this message is invalid. We don't add it to the duplicate cache
         // and instead continually penalize peers that repeatedly send this message.
@@ -1758,9 +1769,11 @@ where
 
         // Tells score that message arrived (but is maybe not fully validated yet).
         // Consider the message as delivered for gossip promises.
-        if let Some((peer_score, .., gossip_promises)) = &mut self.peer_score {
+        self.gossip_promises.message_delivered(&msg_id);
+
+        // Tells score that message arrived (but is maybe not fully validated yet).
+        if let Some((peer_score, ..)) = &mut self.peer_score {
             peer_score.validate_message(propagation_source, &msg_id, &message.topic);
-            gossip_promises.message_delivered(&msg_id);
         }
 
         // Add the message to our memcache
@@ -1802,7 +1815,7 @@ where
         raw_message: &RawMessage,
         reject_reason: RejectReason,
     ) {
-        if let Some((peer_score, .., gossip_promises)) = &mut self.peer_score {
+        if let Some((peer_score, ..)) = &mut self.peer_score {
             if let Some(metrics) = self.metrics.as_mut() {
                 metrics.register_invalid_message(&raw_message.topic);
             }
@@ -1817,7 +1830,8 @@ where
                     reject_reason,
                 );
 
-                gossip_promises.reject_message(&message_id, &reject_reason);
+                self.gossip_promises
+                    .reject_message(&message_id, &reject_reason);
             } else {
                 // The message is invalid, we reject it ignoring any gossip promises. If a peer is
                 // advertising this message via an IHAVE and it's invalid it will be double
@@ -1890,7 +1904,7 @@ where
 
                     // if the mesh needs peers add the peer to the mesh
                     if !self.explicit_peers.contains(propagation_source)
-                        && matches!(peer.kind, PeerKind::Gossipsubv1_1 | PeerKind::Gossipsub)
+                        && peer.kind.is_gossipsub()
                         && !Self::score_below_threshold_from_scores(
                             &self.peer_score,
                             propagation_source,
@@ -1994,8 +2008,8 @@ where
 
     /// Applies penalties to peers that did not respond to our IWANT requests.
     fn apply_iwant_penalties(&mut self) {
-        if let Some((peer_score, .., gossip_promises)) = &mut self.peer_score {
-            for (peer, count) in gossip_promises.get_broken_promises() {
+        if let Some((peer_score, ..)) = &mut self.peer_score {
+            for (peer, count) in self.gossip_promises.get_broken_promises() {
                 peer_score.add_penalty(&peer, count);
                 if let Some(metrics) = self.metrics.as_mut() {
                     metrics.register_score_penalty(Penalty::BrokenPromise);
@@ -2216,7 +2230,7 @@ where
                 && peers.len() > 1
                 && self.peer_score.is_some()
             {
-                if let Some((_, thresholds, _, _)) = &self.peer_score {
+                if let Some((_, thresholds, _)) = &self.peer_score {
                     // Opportunistic grafting works as follows: we check the median score of peers
                     // in the mesh; if this score is below the opportunisticGraftThreshold, we
                     // select a few peers at random with score over the median.
@@ -2309,7 +2323,7 @@ where
         for (topic_hash, peers) in self.fanout.iter_mut() {
             let mut to_remove_peers = Vec::new();
             let publish_threshold = match &self.peer_score {
-                Some((_, thresholds, _, _)) => thresholds.publish_threshold,
+                Some((_, thresholds, _)) => thresholds.publish_threshold,
                 _ => 0.0,
             };
             for peer_id in peers.iter() {
@@ -2402,6 +2416,17 @@ where
         }
         self.failed_messages.shrink_to_fit();
 
+        // Flush stale IDONTWANTs.
+        for peer in self.connected_peers.values_mut() {
+            while let Some((_front, instant)) = peer.dont_send.front() {
+                if (*instant + IDONTWANT_TIMEOUT) >= Instant::now() {
+                    break;
+                } else {
+                    peer.dont_send.pop_front();
+                }
+            }
+        }
+
         tracing::debug!("Completed Heartbeat");
         if let Some(metrics) = self.metrics.as_mut() {
             let duration = u64::try_from(start.elapsed().as_millis()).unwrap_or(u64::MAX);
@@ -2557,6 +2582,49 @@ where
         }
     }
 
+    /// Helper function which sends an IDONTWANT message to mesh\[topic\] peers.
+    fn send_idontwant(
+        &mut self,
+        message: &RawMessage,
+        msg_id: &MessageId,
+        propagation_source: &PeerId,
+    ) {
+        let Some(mesh_peers) = self.mesh.get(&message.topic) else {
+            return;
+        };
+
+        let iwant_peers = self.gossip_promises.peers_for_message(msg_id);
+
+        let recipient_peers: Vec<PeerId> = mesh_peers
+            .iter()
+            .chain(iwant_peers.iter())
+            .filter(|peer_id| {
+                *peer_id != propagation_source && Some(*peer_id) != message.source.as_ref()
+            })
+            .cloned()
+            .collect();
+
+        for peer_id in recipient_peers {
+            let Some(peer) = self.connected_peers.get_mut(&peer_id) else {
+                tracing::error!(peer = %peer_id,
+                    "Could not IDONTWANT, peer doesn't exist in connected peer list");
+                continue;
+            };
+
+            // Only gossipsub 1.2 peers support IDONTWANT.
+            if peer.kind != PeerKind::Gossipsubv1_2 {
+                continue;
+            }
+
+            self.send_message(
+                peer_id,
+                RpcOut::IDontWant(IDontWant {
+                    message_ids: vec![msg_id.clone()],
+                }),
+            );
+        }
+    }
+
     /// Helper function which forwards a message to mesh\[topic\] peers.
     ///
     /// Returns true if at least one peer was messaged.
@@ -2612,13 +2680,26 @@ where
         }
 
         // forward the message to peers
-        for peer in recipient_peers.iter() {
-            let event = RpcOut::Forward {
-                message: message.clone(),
-                timeout: Delay::new(self.config.forward_queue_duration()),
-            };
-            tracing::debug!(%peer, message=%msg_id, "Sending message to peer");
-            self.send_message(*peer, event);
+        for peer_id in recipient_peers.iter() {
+            if let Some(peer) = self.connected_peers.get_mut(peer_id) {
+                if peer.dont_send.get(msg_id).is_some() {
+                    tracing::debug!(%peer_id, message=%msg_id, "Peer doesn't want message");
+                    continue;
+                }
+
+                tracing::debug!(%peer_id, message=%msg_id, "Sending message to peer");
+
+                self.send_message(
+                    *peer_id,
+                    RpcOut::Forward {
+                        message: message.clone(),
+                        timeout: Delay::new(self.config.forward_queue_duration()),
+                    },
+                );
+            } else {
+                tracing::error!(peer = %peer_id,
+                    "Could not FORWARD, peer doesn't exist in connected peer list");
+            }
         }
         tracing::debug!("Completed forwarding message");
         true
@@ -2754,7 +2835,7 @@ where
                         failed_messages.non_priority += 1;
                         failed_messages.forward += 1;
                     }
-                    RpcOut::IWant(_) | RpcOut::IHave(_) => {
+                    RpcOut::IWant(_) | RpcOut::IHave(_) | RpcOut::IDontWant(_) => {
                         failed_messages.non_priority += 1;
                     }
                     RpcOut::Graft(_)
@@ -2994,6 +3075,7 @@ where
                 connections: vec![],
                 sender: Sender::new(self.config.connection_handler_queue_len()),
                 topics: Default::default(),
+                dont_send: LinkedHashMap::new(),
             });
         // Add the new connection
         connected_peer.connections.push(connection_id);
@@ -3020,6 +3102,7 @@ where
                 connections: vec![],
                 sender: Sender::new(self.config.connection_handler_queue_len()),
                 topics: Default::default(),
+                dont_send: LinkedHashMap::new(),
             });
         // Add the new connection
         connected_peer.connections.push(connection_id);
@@ -3069,7 +3152,7 @@ where
             }
             HandlerEvent::MessageDropped(rpc) => {
                 // Account for this in the scoring logic
-                if let Some((peer_score, _, _, _)) = &mut self.peer_score {
+                if let Some((peer_score, _, _)) = &mut self.peer_score {
                     peer_score.failed_message_slow_peer(&propagation_source);
                 }
 
@@ -3177,6 +3260,24 @@ where
                             peers,
                             backoff,
                         }) => prune_msgs.push((topic_hash, peers, backoff)),
+                        ControlAction::IDontWant(IDontWant { message_ids }) => {
+                            let Some(peer) = self.connected_peers.get_mut(&propagation_source)
+                            else {
+                                tracing::error!(peer = %propagation_source,
+                                    "Could not handle IDONTWANT, peer doesn't exist in connected peer list");
+                                continue;
+                            };
+                            if let Some(metrics) = self.metrics.as_mut() {
+                                metrics.register_idontwant(message_ids.len());
+                            }
+                            for message_id in message_ids {
+                                peer.dont_send.insert(message_id, Instant::now());
+                                // Don't exceed capacity.
+                                if peer.dont_send.len() > IDONTWANT_CAP {
+                                    peer.dont_send.pop_front();
+                                }
+                            }
+                        }
                     }
                 }
                 if !ihave_msgs.is_empty() {
@@ -3202,16 +3303,14 @@ where
         }
 
         // update scores
-        if let Some((peer_score, _, delay, _)) = &mut self.peer_score {
+        if let Some((peer_score, _, delay)) = &mut self.peer_score {
             if delay.poll_unpin(cx).is_ready() {
                 peer_score.refresh_scores();
-                delay.reset(peer_score.params.decay_interval);
             }
         }
 
         if self.heartbeat.poll_unpin(cx).is_ready() {
             self.heartbeat();
-            self.heartbeat.reset(self.config.heartbeat_interval());
         }
 
         Poll::Pending
@@ -3329,7 +3428,7 @@ fn get_random_peers_dynamic(
         .iter()
         .filter(|(_, p)| p.topics.contains(topic_hash))
         .filter(|(peer_id, _)| f(peer_id))
-        .filter(|(_, p)| p.kind == PeerKind::Gossipsub || p.kind == PeerKind::Gossipsubv1_1)
+        .filter(|(_, p)| p.kind.is_gossipsub())
         .map(|(peer_id, _)| *peer_id)
         .collect::<Vec<PeerId>>();
 
diff --git a/protocols/gossipsub/src/behaviour/tests.rs b/protocols/gossipsub/src/behaviour/tests.rs
index eaa983d214d..54e12e7490b 100644
--- a/protocols/gossipsub/src/behaviour/tests.rs
+++ b/protocols/gossipsub/src/behaviour/tests.rs
@@ -33,13 +33,7 @@ use crate::{
 };
 
 #[derive(Default, Debug)]
-struct InjectNodes<D, F>
-// TODO: remove trait bound Default when this issue is fixed:
-//  https://github.com/colin-kiegel/rust-derive-builder/issues/93
-where
-    D: DataTransform + Default + Clone + Send + 'static,
-    F: TopicSubscriptionFilter + Clone + Default + Send + 'static,
-{
+struct InjectNodes<D, F> {
     peer_no: usize,
     topics: Vec<String>,
     to_subscribe: bool,
@@ -49,6 +43,7 @@ where
     scoring: Option<(PeerScoreParams, PeerScoreThresholds)>,
     data_transform: D,
     subscription_filter: F,
+    peer_kind: Option<PeerKind>,
 }
 
 impl<D, F> InjectNodes<D, F>
@@ -96,7 +91,7 @@ where
 
         let empty = vec![];
         for i in 0..self.peer_no {
-            let (peer, receiver) = add_peer(
+            let (peer, receiver) = add_peer_with_addr_and_kind(
                 &mut gs,
                 if self.to_subscribe {
                     &topic_hashes
@@ -105,6 +100,8 @@ where
                 },
                 i < self.outbound,
                 i < self.explicit,
+                Multiaddr::empty(),
+                self.peer_kind.clone().or(Some(PeerKind::Gossipsubv1_1)),
             );
             peers.push(peer);
             receivers.insert(peer, receiver);
@@ -153,6 +150,11 @@ where
         self.subscription_filter = subscription_filter;
         self
     }
+
+    fn peer_kind(mut self, peer_kind: PeerKind) -> Self {
+        self.peer_kind = Some(peer_kind);
+        self
+    }
 }
 
 fn inject_nodes<D, F>() -> InjectNodes<D, F>
@@ -239,6 +241,7 @@ where
             connections: vec![connection_id],
             topics: Default::default(),
             sender,
+            dont_send: LinkedHashMap::new(),
         },
     );
 
@@ -625,6 +628,7 @@ fn test_join() {
                 connections: vec![connection_id],
                 topics: Default::default(),
                 sender,
+                dont_send: LinkedHashMap::new(),
             },
         );
         receivers.insert(random_peer, receiver);
@@ -1020,6 +1024,7 @@ fn test_get_random_peers() {
                 connections: vec![ConnectionId::new_unchecked(0)],
                 topics: topics.clone(),
                 sender: Sender::new(gs.config.connection_handler_queue_len()),
+                dont_send: LinkedHashMap::new(),
             },
         );
     }
@@ -4614,9 +4619,9 @@ fn test_ignore_too_many_messages_in_ihave() {
     let (peer, receiver) = add_peer(&mut gs, &topics, false, false);
     receivers.insert(peer, receiver);
 
-    // peer has 20 messages
+    //peer has 30 messages
     let mut seq = 0;
-    let message_ids: Vec<_> = (0..20)
+    let message_ids: Vec<_> = (0..30)
         .map(|_| random_message(&mut seq, &topics))
         .map(|msg| gs.data_transform.inbound_transform(msg).unwrap())
         .map(|msg| config.message_id(&msg))
@@ -4658,7 +4663,7 @@ fn test_ignore_too_many_messages_in_ihave() {
     gs.heartbeat();
     gs.handle_ihave(
         &peer,
-        vec![(topics[0].clone(), message_ids[10..20].to_vec())],
+        vec![(topics[0].clone(), message_ids[20..30].to_vec())],
     );
 
     // we sent 10 iwant messages ids via a IWANT rpc.
@@ -5269,6 +5274,194 @@ fn test_graft_without_subscribe() {
     let _ = gs.unsubscribe(&Topic::new(topic));
 }
 
+/// Test that a node sends IDONTWANT messages to the mesh peers
+/// that run Gossipsub v1.2.
+#[test]
+fn sends_idontwant() {
+    let (mut gs, peers, receivers, topic_hashes) = inject_nodes1()
+        .peer_no(5)
+        .topics(vec![String::from("topic1")])
+        .to_subscribe(true)
+        .gs_config(Config::default())
+        .explicit(1)
+        .peer_kind(PeerKind::Gossipsubv1_2)
+        .create_network();
+
+    let local_id = PeerId::random();
+
+    let message = RawMessage {
+        source: Some(peers[1]),
+        data: vec![12],
+        sequence_number: Some(0),
+        topic: topic_hashes[0].clone(),
+        signature: None,
+        key: None,
+        validated: true,
+    };
+    gs.handle_received_message(message.clone(), &local_id);
+    assert_eq!(
+        receivers
+            .into_iter()
+            .fold(0, |mut idontwants, (peer_id, c)| {
+                let non_priority = c.non_priority.get_ref();
+                while !non_priority.is_empty() {
+                    if let Ok(RpcOut::IDontWant(_)) = non_priority.try_recv() {
+                        assert_ne!(peer_id, peers[1]);
+                        idontwants += 1;
+                    }
+                }
+                idontwants
+            }),
+        3,
+        "IDONTWANT was not sent"
+    );
+}
+
+/// Test that a node doesn't send IDONTWANT messages to the mesh peers
+/// that don't run Gossipsub v1.2.
+#[test]
+fn doesnt_send_idontwant() {
+    let (mut gs, peers, receivers, topic_hashes) = inject_nodes1()
+        .peer_no(5)
+        .topics(vec![String::from("topic1")])
+        .to_subscribe(true)
+        .gs_config(Config::default())
+        .explicit(1)
+        .peer_kind(PeerKind::Gossipsubv1_1)
+        .create_network();
+
+    let local_id = PeerId::random();
+
+    let message = RawMessage {
+        source: Some(peers[1]),
+        data: vec![12],
+        sequence_number: Some(0),
+        topic: topic_hashes[0].clone(),
+        signature: None,
+        key: None,
+        validated: true,
+    };
+    gs.handle_received_message(message.clone(), &local_id);
+    assert_eq!(
+        receivers
+            .into_iter()
+            .fold(0, |mut idontwants, (peer_id, c)| {
+                let non_priority = c.non_priority.get_ref();
+                while !non_priority.is_empty() {
+                    if matches!(non_priority.try_recv(), Ok(RpcOut::IDontWant(_)) if peer_id != peers[1]) {
+                        idontwants += 1;
+                    }
+                }
+                idontwants
+            }),
+        0,
+        "IDONTWANT were sent"
+    );
+}
+
+/// Test that a node doesn't forward a messages to the mesh peers
+/// that sent IDONTWANT.
+#[test]
+fn doesnt_forward_idontwant() {
+    let (mut gs, peers, receivers, topic_hashes) = inject_nodes1()
+        .peer_no(4)
+        .topics(vec![String::from("topic1")])
+        .to_subscribe(true)
+        .gs_config(Config::default())
+        .explicit(1)
+        .peer_kind(PeerKind::Gossipsubv1_2)
+        .create_network();
+
+    let local_id = PeerId::random();
+
+    let raw_message = RawMessage {
+        source: Some(peers[1]),
+        data: vec![12],
+        sequence_number: Some(0),
+        topic: topic_hashes[0].clone(),
+        signature: None,
+        key: None,
+        validated: true,
+    };
+    let message = gs
+        .data_transform
+        .inbound_transform(raw_message.clone())
+        .unwrap();
+    let message_id = gs.config.message_id(&message);
+    let peer = gs.connected_peers.get_mut(&peers[2]).unwrap();
+    peer.dont_send.insert(message_id, Instant::now());
+
+    gs.handle_received_message(raw_message.clone(), &local_id);
+    assert_eq!(
+        receivers.into_iter().fold(0, |mut fwds, (peer_id, c)| {
+            let non_priority = c.non_priority.get_ref();
+            while !non_priority.is_empty() {
+                if let Ok(RpcOut::Forward { .. }) = non_priority.try_recv() {
+                    assert_ne!(peer_id, peers[2]);
+                    fwds += 1;
+                }
+            }
+            fwds
+        }),
+        2,
+        "IDONTWANT was not sent"
+    );
+}
+
+/// Test that a node parses an
+/// IDONTWANT message to the respective peer.
+#[test]
+fn parses_idontwant() {
+    let (mut gs, peers, _receivers, _topic_hashes) = inject_nodes1()
+        .peer_no(2)
+        .topics(vec![String::from("topic1")])
+        .to_subscribe(true)
+        .gs_config(Config::default())
+        .explicit(1)
+        .peer_kind(PeerKind::Gossipsubv1_2)
+        .create_network();
+
+    let message_id = MessageId::new(&[0, 1, 2, 3]);
+    let rpc = Rpc {
+        messages: vec![],
+        subscriptions: vec![],
+        control_msgs: vec![ControlAction::IDontWant(IDontWant {
+            message_ids: vec![message_id.clone()],
+        })],
+    };
+    gs.on_connection_handler_event(
+        peers[1],
+        ConnectionId::new_unchecked(0),
+        HandlerEvent::Message {
+            rpc,
+            invalid_messages: vec![],
+        },
+    );
+    let peer = gs.connected_peers.get_mut(&peers[1]).unwrap();
+    assert!(peer.dont_send.get(&message_id).is_some());
+}
+
+/// Test that a node clears stale IDONTWANT messages.
+#[test]
+fn clear_stale_idontwant() {
+    let (mut gs, peers, _receivers, _topic_hashes) = inject_nodes1()
+        .peer_no(4)
+        .topics(vec![String::from("topic1")])
+        .to_subscribe(true)
+        .gs_config(Config::default())
+        .explicit(1)
+        .peer_kind(PeerKind::Gossipsubv1_2)
+        .create_network();
+
+    let peer = gs.connected_peers.get_mut(&peers[2]).unwrap();
+    peer.dont_send
+        .insert(MessageId::new(&[1, 2, 3, 4]), Instant::now());
+    std::thread::sleep(Duration::from_secs(3));
+    gs.heartbeat();
+    let peer = gs.connected_peers.get_mut(&peers[2]).unwrap();
+    assert!(peer.dont_send.is_empty());
+}
+
 #[test]
 fn test_all_queues_full() {
     let gs_config = ConfigBuilder::default()
@@ -5292,6 +5485,7 @@ fn test_all_queues_full() {
             connections: vec![ConnectionId::new_unchecked(0)],
             topics: topics.clone(),
             sender: Sender::new(2),
+            dont_send: LinkedHashMap::new(),
         },
     );
 
@@ -5326,6 +5520,7 @@ fn test_slow_peer_returns_failed_publish() {
             connections: vec![ConnectionId::new_unchecked(0)],
             topics: topics.clone(),
             sender: Sender::new(2),
+            dont_send: LinkedHashMap::new(),
         },
     );
     let peer_id = PeerId::random();
@@ -5337,6 +5532,7 @@ fn test_slow_peer_returns_failed_publish() {
             connections: vec![ConnectionId::new_unchecked(0)],
             topics: topics.clone(),
             sender: Sender::new(gs.config.connection_handler_queue_len()),
+            dont_send: LinkedHashMap::new(),
         },
     );
 
@@ -5397,6 +5593,7 @@ fn test_slow_peer_returns_failed_ihave_handling() {
             connections: vec![ConnectionId::new_unchecked(0)],
             topics: topics.clone(),
             sender: Sender::new(2),
+            dont_send: LinkedHashMap::new(),
         },
     );
     peers.push(slow_peer_id);
@@ -5412,6 +5609,7 @@ fn test_slow_peer_returns_failed_ihave_handling() {
             connections: vec![ConnectionId::new_unchecked(0)],
             topics: topics.clone(),
             sender: Sender::new(gs.config.connection_handler_queue_len()),
+            dont_send: LinkedHashMap::new(),
         },
     );
 
@@ -5490,6 +5688,7 @@ fn test_slow_peer_returns_failed_iwant_handling() {
             connections: vec![ConnectionId::new_unchecked(0)],
             topics: topics.clone(),
             sender: Sender::new(2),
+            dont_send: LinkedHashMap::new(),
         },
     );
     peers.push(slow_peer_id);
@@ -5505,6 +5704,7 @@ fn test_slow_peer_returns_failed_iwant_handling() {
             connections: vec![ConnectionId::new_unchecked(0)],
             topics: topics.clone(),
             sender: Sender::new(gs.config.connection_handler_queue_len()),
+            dont_send: LinkedHashMap::new(),
         },
     );
 
@@ -5580,6 +5780,7 @@ fn test_slow_peer_returns_failed_forward() {
             connections: vec![ConnectionId::new_unchecked(0)],
             topics: topics.clone(),
             sender: Sender::new(2),
+            dont_send: LinkedHashMap::new(),
         },
     );
     peers.push(slow_peer_id);
@@ -5595,6 +5796,7 @@ fn test_slow_peer_returns_failed_forward() {
             connections: vec![ConnectionId::new_unchecked(0)],
             topics: topics.clone(),
             sender: Sender::new(gs.config.connection_handler_queue_len()),
+            dont_send: LinkedHashMap::new(),
         },
     );
 
@@ -5675,6 +5877,7 @@ fn test_slow_peer_is_downscored_on_publish() {
             connections: vec![ConnectionId::new_unchecked(0)],
             topics: topics.clone(),
             sender: Sender::new(2),
+            dont_send: LinkedHashMap::new(),
         },
     );
     gs.peer_score.as_mut().unwrap().0.add_peer(slow_peer_id);
@@ -5687,6 +5890,7 @@ fn test_slow_peer_is_downscored_on_publish() {
             connections: vec![ConnectionId::new_unchecked(0)],
             topics: topics.clone(),
             sender: Sender::new(gs.config.connection_handler_queue_len()),
+            dont_send: LinkedHashMap::new(),
         },
     );
 
diff --git a/protocols/gossipsub/src/generated/gossipsub/pb.rs b/protocols/gossipsub/src/generated/gossipsub/pb.rs
index 9a074fd61fc..c6a86fcfe92 100644
--- a/protocols/gossipsub/src/generated/gossipsub/pb.rs
+++ b/protocols/gossipsub/src/generated/gossipsub/pb.rs
@@ -40,9 +40,9 @@ impl<'a> MessageRead<'a> for RPC {
 impl MessageWrite for RPC {
     fn get_size(&self) -> usize {
         0
-        + self.subscriptions.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
-        + self.publish.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
-        + self.control.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+            + self.subscriptions.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
+            + self.publish.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
+            + self.control.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
     }
 
     fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
@@ -55,43 +55,43 @@ impl MessageWrite for RPC {
 
 pub mod mod_RPC {
 
-use super::*;
-
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Debug, Default, PartialEq, Clone)]
-pub struct SubOpts {
-    pub subscribe: Option<bool>,
-    pub topic_id: Option<String>,
-}
-
-impl<'a> MessageRead<'a> for SubOpts {
-    fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
-        let mut msg = Self::default();
-        while !r.is_eof() {
-            match r.next_tag(bytes) {
-                Ok(8) => msg.subscribe = Some(r.read_bool(bytes)?),
-                Ok(18) => msg.topic_id = Some(r.read_string(bytes)?.to_owned()),
-                Ok(t) => { r.read_unknown(bytes, t)?; }
-                Err(e) => return Err(e),
+    use super::*;
+
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Debug, Default, PartialEq, Clone)]
+    pub struct SubOpts {
+        pub subscribe: Option<bool>,
+        pub topic_id: Option<String>,
+    }
+
+    impl<'a> MessageRead<'a> for SubOpts {
+        fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
+            let mut msg = Self::default();
+            while !r.is_eof() {
+                match r.next_tag(bytes) {
+                    Ok(8) => msg.subscribe = Some(r.read_bool(bytes)?),
+                    Ok(18) => msg.topic_id = Some(r.read_string(bytes)?.to_owned()),
+                    Ok(t) => { r.read_unknown(bytes, t)?; }
+                    Err(e) => return Err(e),
+                }
             }
+            Ok(msg)
         }
-        Ok(msg)
     }
-}
 
-impl MessageWrite for SubOpts {
-    fn get_size(&self) -> usize {
-        0
-        + self.subscribe.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64))
-        + self.topic_id.as_ref().map_or(0, |m| 1 + sizeof_len((m).len()))
-    }
+    impl MessageWrite for SubOpts {
+        fn get_size(&self) -> usize {
+            0
+                + self.subscribe.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64))
+                + self.topic_id.as_ref().map_or(0, |m| 1 + sizeof_len((m).len()))
+        }
 
-    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
-        if let Some(ref s) = self.subscribe { w.write_with_tag(8, |w| w.write_bool(*s))?; }
-        if let Some(ref s) = self.topic_id { w.write_with_tag(18, |w| w.write_string(&**s))?; }
-        Ok(())
+        fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
+            if let Some(ref s) = self.subscribe { w.write_with_tag(8, |w| w.write_bool(*s))?; }
+            if let Some(ref s) = self.topic_id { w.write_with_tag(18, |w| w.write_string(&**s))?; }
+            Ok(())
+        }
     }
-}
 
 }
 
@@ -128,12 +128,12 @@ impl<'a> MessageRead<'a> for Message {
 impl MessageWrite for Message {
     fn get_size(&self) -> usize {
         0
-        + self.from.as_ref().map_or(0, |m| 1 + sizeof_len((m).len()))
-        + self.data.as_ref().map_or(0, |m| 1 + sizeof_len((m).len()))
-        + self.seqno.as_ref().map_or(0, |m| 1 + sizeof_len((m).len()))
-        + 1 + sizeof_len((&self.topic).len())
-        + self.signature.as_ref().map_or(0, |m| 1 + sizeof_len((m).len()))
-        + self.key.as_ref().map_or(0, |m| 1 + sizeof_len((m).len()))
+            + self.from.as_ref().map_or(0, |m| 1 + sizeof_len((m).len()))
+            + self.data.as_ref().map_or(0, |m| 1 + sizeof_len((m).len()))
+            + self.seqno.as_ref().map_or(0, |m| 1 + sizeof_len((m).len()))
+            + 1 + sizeof_len((&self.topic).len())
+            + self.signature.as_ref().map_or(0, |m| 1 + sizeof_len((m).len()))
+            + self.key.as_ref().map_or(0, |m| 1 + sizeof_len((m).len()))
     }
 
     fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
@@ -154,6 +154,7 @@ pub struct ControlMessage {
     pub iwant: Vec<gossipsub::pb::ControlIWant>,
     pub graft: Vec<gossipsub::pb::ControlGraft>,
     pub prune: Vec<gossipsub::pb::ControlPrune>,
+    pub idontwant: Vec<gossipsub::pb::ControlIDontWant>,
 }
 
 impl<'a> MessageRead<'a> for ControlMessage {
@@ -165,6 +166,7 @@ impl<'a> MessageRead<'a> for ControlMessage {
                 Ok(18) => msg.iwant.push(r.read_message::<gossipsub::pb::ControlIWant>(bytes)?),
                 Ok(26) => msg.graft.push(r.read_message::<gossipsub::pb::ControlGraft>(bytes)?),
                 Ok(34) => msg.prune.push(r.read_message::<gossipsub::pb::ControlPrune>(bytes)?),
+                Ok(42) => msg.idontwant.push(r.read_message::<gossipsub::pb::ControlIDontWant>(bytes)?),
                 Ok(t) => { r.read_unknown(bytes, t)?; }
                 Err(e) => return Err(e),
             }
@@ -176,10 +178,11 @@ impl<'a> MessageRead<'a> for ControlMessage {
 impl MessageWrite for ControlMessage {
     fn get_size(&self) -> usize {
         0
-        + self.ihave.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
-        + self.iwant.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
-        + self.graft.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
-        + self.prune.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
+            + self.ihave.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
+            + self.iwant.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
+            + self.graft.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
+            + self.prune.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
+            + self.idontwant.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
     }
 
     fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
@@ -187,6 +190,7 @@ impl MessageWrite for ControlMessage {
         for s in &self.iwant { w.write_with_tag(18, |w| w.write_message(s))?; }
         for s in &self.graft { w.write_with_tag(26, |w| w.write_message(s))?; }
         for s in &self.prune { w.write_with_tag(34, |w| w.write_message(s))?; }
+        for s in &self.idontwant { w.write_with_tag(42, |w| w.write_message(s))?; }
         Ok(())
     }
 }
@@ -216,8 +220,8 @@ impl<'a> MessageRead<'a> for ControlIHave {
 impl MessageWrite for ControlIHave {
     fn get_size(&self) -> usize {
         0
-        + self.topic_id.as_ref().map_or(0, |m| 1 + sizeof_len((m).len()))
-        + self.message_ids.iter().map(|s| 1 + sizeof_len((s).len())).sum::<usize>()
+            + self.topic_id.as_ref().map_or(0, |m| 1 + sizeof_len((m).len()))
+            + self.message_ids.iter().map(|s| 1 + sizeof_len((s).len())).sum::<usize>()
     }
 
     fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
@@ -250,7 +254,7 @@ impl<'a> MessageRead<'a> for ControlIWant {
 impl MessageWrite for ControlIWant {
     fn get_size(&self) -> usize {
         0
-        + self.message_ids.iter().map(|s| 1 + sizeof_len((s).len())).sum::<usize>()
+            + self.message_ids.iter().map(|s| 1 + sizeof_len((s).len())).sum::<usize>()
     }
 
     fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
@@ -282,7 +286,7 @@ impl<'a> MessageRead<'a> for ControlGraft {
 impl MessageWrite for ControlGraft {
     fn get_size(&self) -> usize {
         0
-        + self.topic_id.as_ref().map_or(0, |m| 1 + sizeof_len((m).len()))
+            + self.topic_id.as_ref().map_or(0, |m| 1 + sizeof_len((m).len()))
     }
 
     fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
@@ -318,9 +322,9 @@ impl<'a> MessageRead<'a> for ControlPrune {
 impl MessageWrite for ControlPrune {
     fn get_size(&self) -> usize {
         0
-        + self.topic_id.as_ref().map_or(0, |m| 1 + sizeof_len((m).len()))
-        + self.peers.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
-        + self.backoff.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64))
+            + self.topic_id.as_ref().map_or(0, |m| 1 + sizeof_len((m).len()))
+            + self.peers.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
+            + self.backoff.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64))
     }
 
     fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
@@ -331,6 +335,38 @@ impl MessageWrite for ControlPrune {
     }
 }
 
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Debug, Default, PartialEq, Clone)]
+pub struct ControlIDontWant {
+    pub message_ids: Vec<Vec<u8>>,
+}
+
+impl<'a> MessageRead<'a> for ControlIDontWant {
+    fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
+        let mut msg = Self::default();
+        while !r.is_eof() {
+            match r.next_tag(bytes) {
+                Ok(10) => msg.message_ids.push(r.read_bytes(bytes)?.to_owned()),
+                Ok(t) => { r.read_unknown(bytes, t)?; }
+                Err(e) => return Err(e),
+            }
+        }
+        Ok(msg)
+    }
+}
+
+impl MessageWrite for ControlIDontWant {
+    fn get_size(&self) -> usize {
+        0
+            + self.message_ids.iter().map(|s| 1 + sizeof_len((s).len())).sum::<usize>()
+    }
+
+    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
+        for s in &self.message_ids { w.write_with_tag(10, |w| w.write_bytes(&**s))?; }
+        Ok(())
+    }
+}
+
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Debug, Default, PartialEq, Clone)]
 pub struct PeerInfo {
@@ -356,8 +392,8 @@ impl<'a> MessageRead<'a> for PeerInfo {
 impl MessageWrite for PeerInfo {
     fn get_size(&self) -> usize {
         0
-        + self.peer_id.as_ref().map_or(0, |m| 1 + sizeof_len((m).len()))
-        + self.signed_peer_record.as_ref().map_or(0, |m| 1 + sizeof_len((m).len()))
+            + self.peer_id.as_ref().map_or(0, |m| 1 + sizeof_len((m).len()))
+            + self.signed_peer_record.as_ref().map_or(0, |m| 1 + sizeof_len((m).len()))
     }
 
     fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
@@ -394,9 +430,9 @@ impl<'a> MessageRead<'a> for TopicDescriptor {
 impl MessageWrite for TopicDescriptor {
     fn get_size(&self) -> usize {
         0
-        + self.name.as_ref().map_or(0, |m| 1 + sizeof_len((m).len()))
-        + self.auth.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
-        + self.enc.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+            + self.name.as_ref().map_or(0, |m| 1 + sizeof_len((m).len()))
+            + self.auth.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+            + self.enc.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
     }
 
     fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
@@ -409,159 +445,159 @@ impl MessageWrite for TopicDescriptor {
 
 pub mod mod_TopicDescriptor {
 
-use super::*;
-
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Debug, Default, PartialEq, Clone)]
-pub struct AuthOpts {
-    pub mode: Option<gossipsub::pb::mod_TopicDescriptor::mod_AuthOpts::AuthMode>,
-    pub keys: Vec<Vec<u8>>,
-}
-
-impl<'a> MessageRead<'a> for AuthOpts {
-    fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
-        let mut msg = Self::default();
-        while !r.is_eof() {
-            match r.next_tag(bytes) {
-                Ok(8) => msg.mode = Some(r.read_enum(bytes)?),
-                Ok(18) => msg.keys.push(r.read_bytes(bytes)?.to_owned()),
-                Ok(t) => { r.read_unknown(bytes, t)?; }
-                Err(e) => return Err(e),
+    use super::*;
+
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Debug, Default, PartialEq, Clone)]
+    pub struct AuthOpts {
+        pub mode: Option<gossipsub::pb::mod_TopicDescriptor::mod_AuthOpts::AuthMode>,
+        pub keys: Vec<Vec<u8>>,
+    }
+
+    impl<'a> MessageRead<'a> for AuthOpts {
+        fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
+            let mut msg = Self::default();
+            while !r.is_eof() {
+                match r.next_tag(bytes) {
+                    Ok(8) => msg.mode = Some(r.read_enum(bytes)?),
+                    Ok(18) => msg.keys.push(r.read_bytes(bytes)?.to_owned()),
+                    Ok(t) => { r.read_unknown(bytes, t)?; }
+                    Err(e) => return Err(e),
+                }
             }
+            Ok(msg)
         }
-        Ok(msg)
     }
-}
 
-impl MessageWrite for AuthOpts {
-    fn get_size(&self) -> usize {
-        0
-        + self.mode.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64))
-        + self.keys.iter().map(|s| 1 + sizeof_len((s).len())).sum::<usize>()
-    }
+    impl MessageWrite for AuthOpts {
+        fn get_size(&self) -> usize {
+            0
+                + self.mode.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64))
+                + self.keys.iter().map(|s| 1 + sizeof_len((s).len())).sum::<usize>()
+        }
 
-    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
-        if let Some(ref s) = self.mode { w.write_with_tag(8, |w| w.write_enum(*s as i32))?; }
-        for s in &self.keys { w.write_with_tag(18, |w| w.write_bytes(&**s))?; }
-        Ok(())
+        fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
+            if let Some(ref s) = self.mode { w.write_with_tag(8, |w| w.write_enum(*s as i32))?; }
+            for s in &self.keys { w.write_with_tag(18, |w| w.write_bytes(&**s))?; }
+            Ok(())
+        }
     }
-}
 
-pub mod mod_AuthOpts {
+    pub mod mod_AuthOpts {
 
 
-#[derive(Debug, PartialEq, Eq, Clone, Copy)]
-pub enum AuthMode {
-    NONE = 0,
-    KEY = 1,
-    WOT = 2,
-}
+        #[derive(Debug, PartialEq, Eq, Clone, Copy)]
+        pub enum AuthMode {
+            NONE = 0,
+            KEY = 1,
+            WOT = 2,
+        }
 
-impl Default for AuthMode {
-    fn default() -> Self {
-        AuthMode::NONE
-    }
-}
+        impl Default for AuthMode {
+            fn default() -> Self {
+                AuthMode::NONE
+            }
+        }
 
-impl From<i32> for AuthMode {
-    fn from(i: i32) -> Self {
-        match i {
-            0 => AuthMode::NONE,
-            1 => AuthMode::KEY,
-            2 => AuthMode::WOT,
-            _ => Self::default(),
+        impl From<i32> for AuthMode {
+            fn from(i: i32) -> Self {
+                match i {
+                    0 => AuthMode::NONE,
+                    1 => AuthMode::KEY,
+                    2 => AuthMode::WOT,
+                    _ => Self::default(),
+                }
+            }
         }
-    }
-}
 
-impl<'a> From<&'a str> for AuthMode {
-    fn from(s: &'a str) -> Self {
-        match s {
-            "NONE" => AuthMode::NONE,
-            "KEY" => AuthMode::KEY,
-            "WOT" => AuthMode::WOT,
-            _ => Self::default(),
+        impl<'a> From<&'a str> for AuthMode {
+            fn from(s: &'a str) -> Self {
+                match s {
+                    "NONE" => AuthMode::NONE,
+                    "KEY" => AuthMode::KEY,
+                    "WOT" => AuthMode::WOT,
+                    _ => Self::default(),
+                }
+            }
         }
-    }
-}
 
-}
+    }
 
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Debug, Default, PartialEq, Clone)]
-pub struct EncOpts {
-    pub mode: Option<gossipsub::pb::mod_TopicDescriptor::mod_EncOpts::EncMode>,
-    pub key_hashes: Vec<Vec<u8>>,
-}
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Debug, Default, PartialEq, Clone)]
+    pub struct EncOpts {
+        pub mode: Option<gossipsub::pb::mod_TopicDescriptor::mod_EncOpts::EncMode>,
+        pub key_hashes: Vec<Vec<u8>>,
+    }
 
-impl<'a> MessageRead<'a> for EncOpts {
-    fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
-        let mut msg = Self::default();
-        while !r.is_eof() {
-            match r.next_tag(bytes) {
-                Ok(8) => msg.mode = Some(r.read_enum(bytes)?),
-                Ok(18) => msg.key_hashes.push(r.read_bytes(bytes)?.to_owned()),
-                Ok(t) => { r.read_unknown(bytes, t)?; }
-                Err(e) => return Err(e),
+    impl<'a> MessageRead<'a> for EncOpts {
+        fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
+            let mut msg = Self::default();
+            while !r.is_eof() {
+                match r.next_tag(bytes) {
+                    Ok(8) => msg.mode = Some(r.read_enum(bytes)?),
+                    Ok(18) => msg.key_hashes.push(r.read_bytes(bytes)?.to_owned()),
+                    Ok(t) => { r.read_unknown(bytes, t)?; }
+                    Err(e) => return Err(e),
+                }
             }
+            Ok(msg)
         }
-        Ok(msg)
     }
-}
 
-impl MessageWrite for EncOpts {
-    fn get_size(&self) -> usize {
-        0
-        + self.mode.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64))
-        + self.key_hashes.iter().map(|s| 1 + sizeof_len((s).len())).sum::<usize>()
-    }
+    impl MessageWrite for EncOpts {
+        fn get_size(&self) -> usize {
+            0
+                + self.mode.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64))
+                + self.key_hashes.iter().map(|s| 1 + sizeof_len((s).len())).sum::<usize>()
+        }
 
-    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
-        if let Some(ref s) = self.mode { w.write_with_tag(8, |w| w.write_enum(*s as i32))?; }
-        for s in &self.key_hashes { w.write_with_tag(18, |w| w.write_bytes(&**s))?; }
-        Ok(())
+        fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
+            if let Some(ref s) = self.mode { w.write_with_tag(8, |w| w.write_enum(*s as i32))?; }
+            for s in &self.key_hashes { w.write_with_tag(18, |w| w.write_bytes(&**s))?; }
+            Ok(())
+        }
     }
-}
 
-pub mod mod_EncOpts {
+    pub mod mod_EncOpts {
 
 
-#[derive(Debug, PartialEq, Eq, Clone, Copy)]
-pub enum EncMode {
-    NONE = 0,
-    SHAREDKEY = 1,
-    WOT = 2,
-}
+        #[derive(Debug, PartialEq, Eq, Clone, Copy)]
+        pub enum EncMode {
+            NONE = 0,
+            SHAREDKEY = 1,
+            WOT = 2,
+        }
 
-impl Default for EncMode {
-    fn default() -> Self {
-        EncMode::NONE
-    }
-}
+        impl Default for EncMode {
+            fn default() -> Self {
+                EncMode::NONE
+            }
+        }
 
-impl From<i32> for EncMode {
-    fn from(i: i32) -> Self {
-        match i {
-            0 => EncMode::NONE,
-            1 => EncMode::SHAREDKEY,
-            2 => EncMode::WOT,
-            _ => Self::default(),
+        impl From<i32> for EncMode {
+            fn from(i: i32) -> Self {
+                match i {
+                    0 => EncMode::NONE,
+                    1 => EncMode::SHAREDKEY,
+                    2 => EncMode::WOT,
+                    _ => Self::default(),
+                }
+            }
         }
-    }
-}
 
-impl<'a> From<&'a str> for EncMode {
-    fn from(s: &'a str) -> Self {
-        match s {
-            "NONE" => EncMode::NONE,
-            "SHAREDKEY" => EncMode::SHAREDKEY,
-            "WOT" => EncMode::WOT,
-            _ => Self::default(),
+        impl<'a> From<&'a str> for EncMode {
+            fn from(s: &'a str) -> Self {
+                match s {
+                    "NONE" => EncMode::NONE,
+                    "SHAREDKEY" => EncMode::SHAREDKEY,
+                    "WOT" => EncMode::WOT,
+                    _ => Self::default(),
+                }
+            }
         }
-    }
-}
 
-}
+    }
 
 }
 
diff --git a/protocols/gossipsub/src/generated/rpc.proto b/protocols/gossipsub/src/generated/rpc.proto
index 2ce12f3f37f..fe4d3bc9366 100644
--- a/protocols/gossipsub/src/generated/rpc.proto
+++ b/protocols/gossipsub/src/generated/rpc.proto
@@ -19,8 +19,8 @@ message Message {
 	optional bytes data = 2;
 	optional bytes seqno = 3;
 	required string topic = 4;
-  optional bytes signature = 5;
-  optional bytes key = 6;
+	optional bytes signature = 5;
+	optional bytes key = 6;
 }
 
 message ControlMessage {
@@ -28,6 +28,7 @@ message ControlMessage {
 	repeated ControlIWant iwant = 2;
 	repeated ControlGraft graft = 3;
 	repeated ControlPrune prune = 4;
+	repeated ControlIDontWant idontwant = 5;
 }
 
 message ControlIHave {
@@ -49,6 +50,10 @@ message ControlPrune {
 	optional uint64 backoff = 3; // gossipsub v1.1 backoff time (in seconds)
 }
 
+message ControlIDontWant {
+	repeated bytes message_ids = 1;
+}
+
 message PeerInfo {
 	optional bytes peer_id = 1;
 	optional bytes signed_peer_record = 2;
diff --git a/protocols/gossipsub/src/gossip_promises.rs b/protocols/gossipsub/src/gossip_promises.rs
index b64811bb062..284ba7cab01 100644
--- a/protocols/gossipsub/src/gossip_promises.rs
+++ b/protocols/gossipsub/src/gossip_promises.rs
@@ -41,6 +41,14 @@ impl GossipPromises {
         self.promises.contains_key(message)
     }
 
+    /// Get the peers we sent IWANT the input message id.
+    pub(crate) fn peers_for_message(&self, message_id: &MessageId) -> Vec<PeerId> {
+        self.promises
+            .get(message_id)
+            .map(|peers| peers.keys().copied().collect())
+            .unwrap_or_default()
+    }
+
     /// Track a promise to deliver a message from a list of [`MessageId`]s we are requesting.
     pub(crate) fn add_promise(&mut self, peer: PeerId, messages: &[MessageId], expires: Instant) {
         for message_id in messages {
diff --git a/protocols/gossipsub/src/metrics.rs b/protocols/gossipsub/src/metrics.rs
index 2519da64b73..42dedc000b7 100644
--- a/protocols/gossipsub/src/metrics.rs
+++ b/protocols/gossipsub/src/metrics.rs
@@ -187,6 +187,12 @@ pub(crate) struct Metrics {
     /// topic. A very high metric might indicate an underperforming network.
     topic_iwant_msgs: Family<TopicHash, Counter>,
 
+    /// The number of times we have received an IDONTWANT control message.
+    idontwant_msgs: Counter,
+
+    /// The number of msg_id's we have received in every IDONTWANT control message.
+    idontwant_msgs_ids: Counter,
+
     /// The size of the priority queue.
     priority_queue_size: Histogram,
     /// The size of the non-priority queue.
@@ -324,6 +330,27 @@ impl Metrics {
             "topic_iwant_msgs",
             "Number of times we have decided an IWANT is required for this topic"
         );
+
+        let idontwant_msgs = {
+            let metric = Counter::default();
+            registry.register(
+                "idontwant_msgs",
+                "The number of times we have received an IDONTWANT control message",
+                metric.clone(),
+            );
+            metric
+        };
+
+        let idontwant_msgs_ids = {
+            let metric = Counter::default();
+            registry.register(
+                "idontwant_msgs_ids",
+                "The number of msg_id's we have received in every total of all IDONTWANT control message.",
+                metric.clone(),
+            );
+            metric
+        };
+
         let memcache_misses = {
             let metric = Counter::default();
             registry.register(
@@ -376,6 +403,8 @@ impl Metrics {
             heartbeat_duration,
             memcache_misses,
             topic_iwant_msgs,
+            idontwant_msgs,
+            idontwant_msgs_ids,
             priority_queue_size,
             non_priority_queue_size,
         }
@@ -574,6 +603,12 @@ impl Metrics {
         }
     }
 
+    /// Register receiving an IDONTWANT msg for this topic.
+    pub(crate) fn register_idontwant(&mut self, msgs: usize) {
+        self.idontwant_msgs.inc();
+        self.idontwant_msgs_ids.inc_by(msgs as u64);
+    }
+
     /// Observes a heartbeat duration.
     pub(crate) fn observe_heartbeat_duration(&mut self, millis: u64) {
         self.heartbeat_duration.observe(millis as f64);
diff --git a/protocols/gossipsub/src/protocol.rs b/protocols/gossipsub/src/protocol.rs
index e4272737342..7ee6d5c8245 100644
--- a/protocols/gossipsub/src/protocol.rs
+++ b/protocols/gossipsub/src/protocol.rs
@@ -35,14 +35,19 @@ use crate::{
     rpc_proto::proto,
     topic::TopicHash,
     types::{
-        ControlAction, Graft, IHave, IWant, MessageId, PeerInfo, PeerKind, Prune, RawMessage, Rpc,
-        Subscription, SubscriptionAction,
+        ControlAction, Graft, IDontWant, IHave, IWant, MessageId, PeerInfo, PeerKind, Prune,
+        RawMessage, Rpc, Subscription, SubscriptionAction,
     },
     ValidationError,
 };
 
 pub(crate) const SIGNING_PREFIX: &[u8] = b"libp2p-pubsub:";
 
+pub(crate) const GOSSIPSUB_1_2_0_PROTOCOL: ProtocolId = ProtocolId {
+    protocol: StreamProtocol::new("/meshsub/1.2.0"),
+    kind: PeerKind::Gossipsubv1_2,
+};
+
 pub(crate) const GOSSIPSUB_1_1_0_PROTOCOL: ProtocolId = ProtocolId {
     protocol: StreamProtocol::new("/meshsub/1.1.0"),
     kind: PeerKind::Gossipsubv1_1,
@@ -72,7 +77,11 @@ impl Default for ProtocolConfig {
         Self {
             max_transmit_size: 65536,
             validation_mode: ValidationMode::Strict,
-            protocol_ids: vec![GOSSIPSUB_1_1_0_PROTOCOL, GOSSIPSUB_1_0_0_PROTOCOL],
+            protocol_ids: vec![
+                GOSSIPSUB_1_2_0_PROTOCOL,
+                GOSSIPSUB_1_1_0_PROTOCOL,
+                GOSSIPSUB_1_0_0_PROTOCOL,
+            ],
         }
     }
 }
@@ -479,10 +488,25 @@ impl Decoder for GossipsubCodec {
                 }));
             }
 
+            let idontwant_msgs: Vec<ControlAction> = rpc_control
+                .idontwant
+                .into_iter()
+                .map(|idontwant| {
+                    ControlAction::IDontWant(IDontWant {
+                        message_ids: idontwant
+                            .message_ids
+                            .into_iter()
+                            .map(MessageId::from)
+                            .collect::<Vec<_>>(),
+                    })
+                })
+                .collect();
+
             control_msgs.extend(ihave_msgs);
             control_msgs.extend(iwant_msgs);
             control_msgs.extend(graft_msgs);
             control_msgs.extend(prune_msgs);
+            control_msgs.extend(idontwant_msgs);
         }
 
         Ok(Some(HandlerEvent::Message {
diff --git a/protocols/gossipsub/src/rpc.rs b/protocols/gossipsub/src/rpc.rs
index b5f05c7b2e5..41b338267e9 100644
--- a/protocols/gossipsub/src/rpc.rs
+++ b/protocols/gossipsub/src/rpc.rs
@@ -89,7 +89,7 @@ impl Sender {
             | RpcOut::Prune(_)
             | RpcOut::Subscribe(_)
             | RpcOut::Unsubscribe(_) => &self.priority_sender,
-            RpcOut::Forward { .. } | RpcOut::IHave(_) | RpcOut::IWant(_) => {
+            RpcOut::Forward { .. } | RpcOut::IHave(_) | RpcOut::IWant(_) | RpcOut::IDontWant(_) => {
                 &self.non_priority_sender
             }
         };
diff --git a/protocols/gossipsub/src/types.rs b/protocols/gossipsub/src/types.rs
index bcb1f279ae5..ccf68e86888 100644
--- a/protocols/gossipsub/src/types.rs
+++ b/protocols/gossipsub/src/types.rs
@@ -22,12 +22,14 @@
 use std::{collections::BTreeSet, fmt, fmt::Debug};
 
 use futures_timer::Delay;
+use hashlink::LinkedHashMap;
 use libp2p_identity::PeerId;
 use libp2p_swarm::ConnectionId;
 use prometheus_client::encoding::EncodeLabelValue;
 use quick_protobuf::MessageWrite;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
+use std::time::Instant;
 
 use crate::{rpc::Sender, rpc_proto::proto, TopicHash};
 
@@ -109,11 +111,16 @@ pub(crate) struct PeerConnections {
     pub(crate) topics: BTreeSet<TopicHash>,
     /// The rpc sender to the connection handler(s).
     pub(crate) sender: Sender,
+    /// Don't send messages.
+    pub(crate) dont_send: LinkedHashMap<MessageId, Instant>,
 }
 
 /// Describes the types of peers that can exist in the gossipsub context.
 #[derive(Debug, Clone, PartialEq, Hash, EncodeLabelValue, Eq)]
+#[allow(non_camel_case_types)]
 pub enum PeerKind {
+    /// A gossipsub 1.2 peer.
+    Gossipsubv1_2,
     /// A gossipsub 1.1 peer.
     Gossipsubv1_1,
     /// A gossipsub 1.0 peer.
@@ -149,6 +156,16 @@ pub struct RawMessage {
     pub validated: bool,
 }
 
+impl PeerKind {
+    /// Returns true if peer speaks any gossipsub version.
+    pub(crate) fn is_gossipsub(&self) -> bool {
+        matches!(
+            self,
+            Self::Gossipsubv1_2 | Self::Gossipsubv1_1 | Self::Gossipsub
+        )
+    }
+}
+
 impl RawMessage {
     /// Calculates the encoded length of this message (used for calculating metrics).
     pub fn raw_protobuf_len(&self) -> usize {
@@ -246,6 +263,8 @@ pub enum ControlAction {
     Graft(Graft),
     /// The node has been removed from the mesh - Prune control message.
     Prune(Prune),
+    /// The node requests us to not forward message ids (peer_id + sequence _number) - IDontWant control message.
+    IDontWant(IDontWant),
 }
 
 /// Node broadcasts known messages per topic - IHave control message.
@@ -282,6 +301,13 @@ pub struct Prune {
     pub(crate) backoff: Option<u64>,
 }
 
+/// The node requests us to not forward message ids - IDontWant control message.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct IDontWant {
+    /// A list of known message ids.
+    pub(crate) message_ids: Vec<MessageId>,
+}
+
 /// A Gossipsub RPC message sent.
 #[derive(Debug)]
 pub enum RpcOut {
@@ -303,6 +329,8 @@ pub enum RpcOut {
     IHave(IHave),
     /// Send a IWant control message.
     IWant(IWant),
+    /// The node requests us to not forward message ids (peer_id + sequence _number) - IDontWant control message.
+    IDontWant(IDontWant),
 }
 
 impl RpcOut {
@@ -363,6 +391,7 @@ impl From<RpcOut> for proto::RPC {
                     iwant: vec![],
                     graft: vec![],
                     prune: vec![],
+                    idontwant: vec![],
                 }),
             },
             RpcOut::IWant(IWant { message_ids }) => proto::RPC {
@@ -375,6 +404,7 @@ impl From<RpcOut> for proto::RPC {
                     }],
                     graft: vec![],
                     prune: vec![],
+                    idontwant: vec![],
                 }),
             },
             RpcOut::Graft(Graft { topic_hash }) => proto::RPC {
@@ -387,6 +417,7 @@ impl From<RpcOut> for proto::RPC {
                         topic_id: Some(topic_hash.into_string()),
                     }],
                     prune: vec![],
+                    idontwant: vec![],
                 }),
             },
             RpcOut::Prune(Prune {
@@ -413,9 +444,23 @@ impl From<RpcOut> for proto::RPC {
                                 .collect(),
                             backoff,
                         }],
+                        idontwant: vec![],
                     }),
                 }
             }
+            RpcOut::IDontWant(IDontWant { message_ids }) => proto::RPC {
+                publish: Vec::new(),
+                subscriptions: Vec::new(),
+                control: Some(proto::ControlMessage {
+                    ihave: vec![],
+                    iwant: vec![],
+                    graft: vec![],
+                    prune: vec![],
+                    idontwant: vec![proto::ControlIDontWant {
+                        message_ids: message_ids.into_iter().map(|msg_id| msg_id.0).collect(),
+                    }],
+                }),
+            },
         }
     }
 }
@@ -474,6 +519,7 @@ impl From<Rpc> for proto::RPC {
             iwant: Vec::new(),
             graft: Vec::new(),
             prune: Vec::new(),
+            idontwant: Vec::new(),
         };
 
         let empty_control_msg = rpc.control_msgs.is_empty();
@@ -522,6 +568,12 @@ impl From<Rpc> for proto::RPC {
                     };
                     control.prune.push(rpc_prune);
                 }
+                ControlAction::IDontWant(IDontWant { message_ids }) => {
+                    let rpc_idontwant = proto::ControlIDontWant {
+                        message_ids: message_ids.into_iter().map(|msg_id| msg_id.0).collect(),
+                    };
+                    control.idontwant.push(rpc_idontwant);
+                }
             }
         }
 
@@ -560,6 +612,7 @@ impl PeerKind {
             Self::Floodsub => "Floodsub",
             Self::Gossipsub => "Gossipsub v1.0",
             Self::Gossipsubv1_1 => "Gossipsub v1.1",
+            Self::Gossipsubv1_2 => "Gossipsub v1.2",
         }
     }
 }