diff --git a/src/chain/cfheader_batch.rs b/src/chain/cfheader_batch.rs
deleted file mode 100644
index 05e6b7f7..00000000
--- a/src/chain/cfheader_batch.rs
+++ /dev/null
@@ -1,55 +0,0 @@
-use bitcoin::{p2p::message_filter::CFHeaders, BlockHash, FilterHeader};
-
-use crate::chain::FilterCommitment;
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct CFHeaderBatch {
-    inner: Vec<FilterCommitment>,
-    prev_filter_header: FilterHeader,
-    stop_hash: BlockHash,
-}
-
-impl CFHeaderBatch {
-    // Although BIP 157 specifies two new message types,
-    // the CFHeader message may make it easier to detect
-    // faulty peers sooner
-    pub(crate) fn new(batch: CFHeaders) -> Self {
-        let mut headers: Vec<FilterCommitment> = vec![];
-        let mut prev_header = batch.previous_filter_header;
-        for hash in batch.filter_hashes {
-            let next_header = hash.filter_header(&prev_header);
-            headers.push(FilterCommitment {
-                header: next_header,
-                filter_hash: hash,
-            });
-            prev_header = next_header;
-        }
-        Self {
-            inner: headers,
-            prev_filter_header: batch.previous_filter_header,
-            stop_hash: batch.stop_hash,
-        }
-    }
-
-    pub(crate) fn prev_header(&self) -> &FilterHeader {
-        &self.prev_filter_header
-    }
-
-    pub(crate) fn stop_hash(&self) -> BlockHash {
-        self.stop_hash
-    }
-
-    pub(crate) fn len(&self) -> u32 {
-        self.inner.len() as u32
-    }
-
-    pub(crate) fn take_inner(&mut self) -> Vec<FilterCommitment> {
-        core::mem::take(&mut self.inner)
-    }
-}
-
-impl From<CFHeaders> for CFHeaderBatch {
-    fn from(val: CFHeaders) -> Self {
-        CFHeaderBatch::new(val)
-    }
-}
diff --git a/src/chain/chain.rs b/src/chain/chain.rs
index 8a426ff8..c523e04a 100644
--- a/src/chain/chain.rs
+++ b/src/chain/chain.rs
@@ -9,11 +9,10 @@ use bitcoin::{
 use tokio::sync::Mutex;
 
 use super::{
-    cfheader_batch::CFHeaderBatch,
     error::{CFHeaderSyncError, CFilterSyncError, HeaderSyncError},
     graph::{AcceptHeaderChanges, BlockTree, HeaderRejection},
-    CFHeaderChanges, ChainState, Filter, FilterCheck, FilterHeaderRequest, FilterRequest,
-    FilterRequestState, HeaderValidationExt, HeightMonitor, PeerId,
+    CFHeaderBatch, CFHeaderChanges, ChainState, Filter, FilterCheck, FilterHeaderRequest,
+    FilterRequest, FilterRequestState, HeaderValidationExt, HeightMonitor, PeerId,
 };
 use crate::IndexedFilter;
 use crate::{chain::BlockHeaderChanges, messages::Event, Dialog, Info, Progress};
diff --git a/src/chain/mod.rs b/src/chain/mod.rs
index 17133797..0fe05427 100644
--- a/src/chain/mod.rs
+++ b/src/chain/mod.rs
@@ -2,7 +2,6 @@
 //!
 //! Notably, [`checkpoints`] contains known Bitcoin block hashes and heights with significant work, so Kyoto nodes do not have to sync from genesis.
 pub(crate) mod block_queue;
-mod cfheader_batch;
 #[allow(clippy::module_inception)]
 pub(crate) mod chain;
 /// Expected block header checkpoints and corresponding structure.
@@ -18,15 +17,13 @@ use bitcoin::constants::SUBSIDY_HALVING_INTERVAL;
 use bitcoin::hashes::{sha256d, Hash};
 use bitcoin::Amount;
 use bitcoin::{
-    bip158::BlockFilter, block::Header, params::Params, BlockHash, FilterHash, FilterHeader,
-    ScriptBuf, Target, Work,
+    bip158::BlockFilter, block::Header, p2p::message_filter::CFHeaders, params::Params, BlockHash,
+    FilterHash, FilterHeader, ScriptBuf, Target, Work,
 };
 
 use crate::network::PeerId;
 use crate::HeaderCheckpoint;
 
-use cfheader_batch::CFHeaderBatch;
-
 type Height = u32;
 
 /// A block header with associated height.
@@ -170,6 +167,55 @@ pub(crate) enum CFHeaderChanges {
     Conflict,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct CFHeaderBatch {
+    inner: Vec<FilterCommitment>,
+    prev_filter_header: FilterHeader,
+    stop_hash: BlockHash,
+}
+
+impl CFHeaderBatch {
+    pub(crate) fn new(batch: CFHeaders) -> Self {
+        let mut headers: Vec<FilterCommitment> = vec![];
+        let mut prev_header = batch.previous_filter_header;
+        for hash in batch.filter_hashes {
+            let next_header = hash.filter_header(&prev_header);
+            headers.push(FilterCommitment {
+                header: next_header,
+                filter_hash: hash,
+            });
+            prev_header = next_header;
+        }
+        Self {
+            inner: headers,
+            prev_filter_header: batch.previous_filter_header,
+            stop_hash: batch.stop_hash,
+        }
+    }
+
+    fn prev_header(&self) -> &FilterHeader {
+        &self.prev_filter_header
+    }
+
+    fn stop_hash(&self) -> BlockHash {
+        self.stop_hash
+    }
+
+    fn len(&self) -> u32 {
+        self.inner.len() as u32
+    }
+
+    fn take_inner(&mut self) -> Vec<FilterCommitment> {
+        core::mem::take(&mut self.inner)
+    }
+}
+
+impl From<CFHeaders> for CFHeaderBatch {
+    fn from(val: CFHeaders) -> Self {
+        CFHeaderBatch::new(val)
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) struct FilterCheck {
     // This filter was for the `stop_hash`