refactor: remove unused bloom_filter protocol

network/src/peers_registry.rs

@@ -321,7 +321,7 @@ impl PeersRegistry {
         &self.peers
     }
 
-    fn peer_indexes_guard(&self) -> &RwLock<FnvHashMap<PeerIndex, PeerId>> {
+    pub fn peer_indexes_guard(&self) -> &RwLock<FnvHashMap<PeerIndex, PeerId>> {
         &self.peer_id_by_index
     }
 

sync/src/synchronizer/get_blocks_process.rs

@@ -40,37 +40,12 @@ where
             debug!(target: "sync", "get_blocks {:x}", block_hash);
             if let Some(block) = self.synchronizer.get_block(&block_hash) {
                 debug!(target: "sync", "respond_block {} {:x}", block.header().number(), block.header().hash());
-                if let Some(filter) = self
-                    .synchronizer
-                    .peers
-                    .transaction_filters
-                    .read()
-                    .get(&self.peer)
-                {
-                    let transactions_index = block
-                        .commit_transactions()
-                        .iter()
-                        .enumerate()
-                        .filter(|(_index, tx)| filter.contains(tx))
-                        .map(|ti| ti.0)
-                        .collect::<Vec<_>>();
-
-                    let fbb = &mut FlatBufferBuilder::new();
-                    let message =
-                        SyncMessage::build_filtered_block(fbb, &block, &transactions_index);
-                    fbb.finish(message, None);
-                    let ret = self.nc.send(self.peer, fbb.finished_data().to_vec());
-                    if ret.is_err() {
-                        warn!(target: "relay", "response GetBlocks error {:?}", ret);
-                    }
-                } else {
-                    let fbb = &mut FlatBufferBuilder::new();
-                    let message = SyncMessage::build_block(fbb, &block);
-                    fbb.finish(message, None);
-                    let ret = self.nc.send(self.peer, fbb.finished_data().to_vec());
-                    if ret.is_err() {
-                        warn!(target: "relay", "response GetBlocks error {:?}", ret);
-                    }
+                let fbb = &mut FlatBufferBuilder::new();
+                let message = SyncMessage::build_block(fbb, &block);
+                fbb.finish(message, None);
+                let ret = self.nc.send(self.peer, fbb.finished_data().to_vec());
+                if ret.is_err() {
+                    warn!(target: "relay", "response GetBlocks error {:?}", ret);
                 }
             } else {
                 // TODO response not found

sync/src/synchronizer/mod.rs

@@ -1,15 +1,13 @@
 mod block_fetcher;
 mod block_pool;
 mod block_process;
-mod filter_process;
 mod get_blocks_process;
 mod get_headers_process;
 mod headers_process;
 
 use self::block_fetcher::BlockFetcher;
 use self::block_pool::OrphanBlockPool;
 use self::block_process::BlockProcess;
-use self::filter_process::{AddFilterProcess, ClearFilterProcess, SetFilterProcess};
 use self::get_blocks_process::GetBlocksProcess;
 use self::get_headers_process::GetHeadersProcess;
 use self::headers_process::HeadersProcess;
@@ -158,22 +156,10 @@ impl<CI: ChainIndex> Synchronizer<CI> {
             SyncPayload::Block => {
                 BlockProcess::new(&cast!(message.payload_as_block())?, self, peer, nc).execute()?;
             }
-            SyncPayload::SetFilter => {
-                SetFilterProcess::new(&cast!(message.payload_as_set_filter())?, self, peer)
-                    .execute()?;
-            }
-            SyncPayload::AddFilter => {
-                AddFilterProcess::new(&cast!(message.payload_as_add_filter())?, self, peer)
-                    .execute()?;
-            }
-            SyncPayload::ClearFilter => {
-                ClearFilterProcess::new(self, peer).execute()?;
-            }
-            SyncPayload::FilteredBlock => {
-                // ignore, should not receive FilteredBlock in full node mode
+            SyncPayload::NONE => {
                 cast!(None)?;
             }
-            SyncPayload::NONE => {
+            _ => {
                 cast!(None)?;
             }
         }

sync/src/tests/mod.rs

@@ -9,7 +9,6 @@ use std::sync::Arc;
 use std::thread;
 use std::time::Duration;
 
-mod filter;
 #[cfg(not(disable_faketime))]
 mod relayer;
 #[cfg(not(disable_faketime))]

sync/src/types.rs

@@ -1,9 +1,5 @@
-use bloom_filters::{
-    BloomFilter, ClassicBloomFilter, DefaultBuildHashKernels, UpdatableBloomFilter,
-};
 use ckb_core::block::Block;
 use ckb_core::header::{BlockNumber, Header};
-use ckb_core::transaction::Transaction;
 use ckb_network::PeerIndex;
 use ckb_util::Mutex;
 use ckb_util::RwLock;
@@ -14,7 +10,6 @@ use lru_cache::LruCache;
 use numext_fixed_hash::H256;
 use numext_fixed_uint::U256;
 use std::collections::hash_map::Entry;
-use std::hash::{BuildHasher, Hasher};
 
 const FILTER_SIZE: usize = 500;
 
@@ -91,7 +86,6 @@ pub struct Peers {
     pub blocks_inflight: RwLock<FnvHashMap<PeerIndex, BlocksInflight>>,
     pub best_known_headers: RwLock<FnvHashMap<PeerIndex, HeaderView>>,
     pub last_common_headers: RwLock<FnvHashMap<PeerIndex, Header>>,
-    pub transaction_filters: RwLock<FnvHashMap<PeerIndex, TransactionFilter>>,
     pub known_txs: Mutex<KnownFilter>,
     pub known_blocks: Mutex<KnownFilter>,
 }
@@ -259,71 +253,3 @@ impl HeaderView {
         self.inner
     }
 }
-
-pub struct TransactionFilter {
-    filter: ClassicBloomFilter<DefaultBuildHashKernels<HighLowBytesBuildHasher>>,
-}
-
-impl TransactionFilter {
-    pub fn new(raw_data: &[u8], k: usize, hash_seed: usize) -> Self {
-        Self {
-            filter: ClassicBloomFilter::with_raw_data(
-                raw_data,
-                k,
-                DefaultBuildHashKernels::new(hash_seed, HighLowBytesBuildHasher),
-            ),
-        }
-    }
-
-    pub fn update(&mut self, raw_data: &[u8]) {
-        self.filter.update(raw_data)
-    }
-
-    pub fn insert(&mut self, hash: &H256) {
-        self.filter.insert(hash);
-    }
-
-    pub fn contains(&self, transaction: &Transaction) -> bool {
-        self.filter.contains(&transaction.hash())
-            || transaction
-                .inputs()
-                .iter()
-                .any(|input| self.filter.contains(&input.previous_output.hash))
-            || transaction
-                .outputs()
-                .iter()
-                .any(|output| self.filter.contains(&output.lock.hash()))
-    }
-}
-
-struct HighLowBytesBuildHasher;
-
-impl BuildHasher for HighLowBytesBuildHasher {
-    type Hasher = HighLowBytesHasher;
-
-    fn build_hasher(&self) -> Self::Hasher {
-        HighLowBytesHasher(0)
-    }
-}
-
-/// a hasher which only accepts H256 bytes and use high / low bytes as hash value
-struct HighLowBytesHasher(u64);
-
-impl Hasher for HighLowBytesHasher {
-    fn write(&mut self, bytes: &[u8]) {
-        if bytes.len() == 32 {
-            self.0 = (u64::from(bytes[0]) << 56)
-                + (u64::from(bytes[1]) << 48)
-                + (u64::from(bytes[2]) << 40)
-                + (u64::from(bytes[3]) << 32)
-                + (u64::from(bytes[28]) << 24)
-                + (u64::from(bytes[29]) << 16)
-                + (u64::from(bytes[30]) << 8)
-                + u64::from(bytes[31]);
-        }
-    }
-
-    fn finish(&self) -> u64 {
-        self.0
-    }
-}