Merge pull request #332 from rustaceanrob/kill-filter-4-15

Remove the `filter` module

Author: rustaceanrob

src/filters/cfheader_batch.rs src/chain/cfheader_batch.rssrc/filters/cfheader_batch.rs renamed to src/chain/cfheader_batch.rs

@@ -14,10 +14,12 @@ use tokio::sync::Mutex;
 
 use super::{
     block_queue::BlockQueue,
+    cfheader_batch::CFHeaderBatch,
     checkpoints::{HeaderCheckpoint, HeaderCheckpoints},
-    error::{BlockScanError, HeaderSyncError},
+    error::{BlockScanError, CFHeaderSyncError, CFilterSyncError, HeaderSyncError},
     graph::{AcceptHeaderChanges, BlockTree, HeaderRejection, Tip},
-    CFHeaderChanges, FilterHeaderRequest, FilterRequest, FilterRequestState, HeightMonitor, PeerId,
+    CFHeaderChanges, Filter, FilterHeaderRequest, FilterRequest, FilterRequestState, HeightMonitor,
+    PeerId,
 };
 #[cfg(feature = "filter-control")]
 use crate::error::FetchBlockError;
@@ -30,17 +32,14 @@ use crate::{
     db::{traits::HeaderStore, BlockHeaderChanges},
     dialog::Dialog,
     error::HeaderPersistenceError,
-    filters::{
-        cfheader_batch::CFHeaderBatch,
-        error::{CFHeaderSyncError, CFilterSyncError},
-        Filter, CF_HEADER_BATCH_SIZE, FILTER_BATCH_SIZE,
-    },
     messages::{Event, Warning},
     IndexedBlock, Info, Progress,
 };
 
 const REORG_LOOKBACK: u32 = 7;
 const FILTER_BASIC: u8 = 0x00;
+const CF_HEADER_BATCH_SIZE: u32 = 1_999;
+const FILTER_BATCH_SIZE: u32 = 999;
 
 #[derive(Debug)]
 pub(crate) struct Chain<H: HeaderStore> {

src/chain/chain.rs

@@ -49,6 +49,101 @@ impl Display for HeaderSyncError {
 
 impl_sourceless_error!(HeaderSyncError);
 
+#[derive(Debug)]
+pub enum CFHeaderSyncError {
+    EmptyMessage,
+    UnknownStophash,
+    StopHashMismatch,
+    UnrequestedStophash,
+    PrevHeaderMismatch,
+    HeaderChainIndexOverflow,
+    UnexpectedCFHeaderMessage,
+    StartHeightMisalignment,
+}
+
+impl core::fmt::Display for CFHeaderSyncError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            CFHeaderSyncError::EmptyMessage => write!(f, "empty headers message."),
+            CFHeaderSyncError::UnknownStophash => {
+                write!(f, "a stop hash received was not found in our chain.")
+            }
+            CFHeaderSyncError::StopHashMismatch => {
+                write!(f, "the requested and received stop hashes do not match.")
+            }
+            CFHeaderSyncError::UnrequestedStophash => {
+                write!(f, "we did not request this stop hash.")
+            }
+            CFHeaderSyncError::PrevHeaderMismatch => write!(f, "previous filter header mismatch."),
+            CFHeaderSyncError::HeaderChainIndexOverflow => write!(
+                f,
+                "indexed out of bounds on the header chain trying to find a block hash."
+            ),
+            CFHeaderSyncError::UnexpectedCFHeaderMessage => write!(
+                f,
+                "we already had a message from this peer staged in our queue."
+            ),
+            CFHeaderSyncError::StartHeightMisalignment => write!(
+                f,
+                "the size of the batch and the requested start height do not align"
+            ),
+        }
+    }
+}
+
+impl_sourceless_error!(CFHeaderSyncError);
+
+#[derive(Debug)]
+pub enum CFilterSyncError {
+    UnknownStophash,
+    UnrequestedStophash,
+    UnknownFilterHash,
+    MisalignedFilterHash,
+    Filter(FilterError),
+}
+
+impl core::fmt::Display for CFilterSyncError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            CFilterSyncError::UnknownStophash => {
+                write!(f, "a stop hash recevied was not found in our chain.")
+            }
+            CFilterSyncError::UnrequestedStophash => {
+                write!(f, "we did not request this stop hash.")
+            }
+            CFilterSyncError::UnknownFilterHash => write!(
+                f,
+                "we could not find the filter hash corresponding to that stop hash."
+            ),
+            CFilterSyncError::MisalignedFilterHash => write!(
+                f,
+                "the filter hash from our header chain and this filter hash do not match."
+            ),
+            CFilterSyncError::Filter(_) => write!(
+                f,
+                "the filter experienced an IO error checking for Script inclusions."
+            ),
+        }
+    }
+}
+
+impl_sourceless_error!(CFilterSyncError);
+
+#[derive(Debug)]
+pub enum FilterError {
+    IORead,
+}
+
+impl core::fmt::Display for FilterError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            FilterError::IORead => write!(f, "unable to read from the filter contents buffer."),
+        }
+    }
+}
+
+impl_sourceless_error!(FilterError);
+
 #[derive(Debug)]
 pub(crate) enum BlockScanError {
     NoBlockHash,

src/chain/error.rs

@@ -2,6 +2,7 @@
 //!
 //! 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.
@@ -14,9 +15,13 @@ pub(crate) mod header_batch;
 
 use std::collections::HashMap;
 
-use bitcoin::{block::Header, BlockHash, FilterHash, FilterHeader};
+use bitcoin::hashes::{sha256d, Hash};
+use bitcoin::{bip158::BlockFilter, block::Header, BlockHash, FilterHash, FilterHeader, ScriptBuf};
 
-use crate::{filters::cfheader_batch::CFHeaderBatch, network::PeerId};
+use crate::network::PeerId;
+
+use cfheader_batch::CFHeaderBatch;
+use error::FilterError;
 
 type Height = u32;
 
@@ -110,6 +115,44 @@ pub(crate) enum CFHeaderChanges {
     Conflict,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct Filter {
+    filter_hash: FilterHash,
+    block_hash: BlockHash,
+    block_filter: BlockFilter,
+}
+
+#[allow(dead_code)]
+impl Filter {
+    pub fn new(contents: Vec<u8>, block_hash: BlockHash) -> Self {
+        let hash = sha256d::Hash::hash(&contents);
+        let filter_hash = FilterHash::from_raw_hash(hash);
+        let block_filter = BlockFilter::new(&contents);
+        Self {
+            filter_hash,
+            block_hash,
+            block_filter,
+        }
+    }
+
+    pub fn filter_hash(&self) -> &FilterHash {
+        &self.filter_hash
+    }
+
+    pub fn block_hash(&self) -> &BlockHash {
+        &self.block_hash
+    }
+
+    pub fn contains_any<'a>(
+        &'a mut self,
+        scripts: impl Iterator<Item = &'a ScriptBuf>,
+    ) -> Result<bool, FilterError> {
+        self.block_filter
+            .match_any(&self.block_hash, scripts.map(|script| script.to_bytes()))
+            .map_err(|_| FilterError::IORead)
+    }
+}
+
 #[derive(Debug)]
 pub(crate) struct HeightMonitor {
     map: HashMap<PeerId, Height>,

src/chain/mod.rs

@@ -78,7 +78,6 @@
 pub mod chain;
 pub mod db;
 
-mod filters;
 mod network;
 mod prelude;
 
@@ -105,7 +104,7 @@ pub type BlockReceiver = tokio::sync::oneshot::Receiver<Result<IndexedBlock, Fet
 #[cfg(feature = "filter-control")]
 use crate::error::FetchBlockError;
 #[cfg(feature = "filter-control")]
-use filters::Filter;
+use chain::Filter;
 #[cfg(feature = "filter-control")]
 use std::collections::HashSet;
 

src/filters/error.rs

@@ -19,12 +19,11 @@ use crate::{
     chain::{
         chain::Chain,
         checkpoints::{HeaderCheckpoint, HeaderCheckpoints},
-        error::HeaderSyncError,
+        error::{CFilterSyncError, HeaderSyncError},
         CFHeaderChanges, HeightMonitor,
     },
     db::traits::{HeaderStore, PeerStore},
     error::FetchHeaderError,
-    filters::error::CFilterSyncError,
     network::{peer_map::PeerMap, LastBlockMonitor, PeerId, PeerTimeoutConfig},
     FilterSyncPolicy, NodeState, RejectPayload, TxBroadcastPolicy,
 };