From 57112af45345b7419c226b274ee3ae89580d6b27 Mon Sep 17 00:00:00 2001
From: rajarshimaitra <rajarshi149@gmail.com>
Date: Sat, 8 Oct 2022 22:52:42 +0530
Subject: [PATCH 1/6] Add nakamoto blockchain

---
 Cargo.toml                                 |   7 +-
 src/blockchain/compact_filters/mod.rs      |   2 +
 src/blockchain/compact_filters/nakamoto.rs | 689 +++++++++++++++++++++
 src/error.rs                               |  13 +
 4 files changed, 710 insertions(+), 1 deletion(-)
 create mode 100644 src/blockchain/compact_filters/nakamoto.rs

diff --git a/Cargo.toml b/Cargo.toml
index 18fcfef62..139d7a66c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -19,6 +19,7 @@ bitcoin = { version = "0.29.1", features = ["serde", "base64", "rand"] }
 serde = { version = "^1.0", features = ["derive"] }
 serde_json = { version = "^1.0" }
 rand = "^0.8"
+thiserror = "1.0"
 
 # Optional dependencies
 sled = { version = "0.34", optional = true }
@@ -39,6 +40,9 @@ bitcoinconsensus = { version = "0.19.0-3", optional = true }
 # Needed by bdk_blockchain_tests macro and the `rpc` feature
 bitcoincore-rpc = { version = "0.16", optional = true }
 
+# Nakamoto crates for the CBF blockchain
+nakamoto = { git = "https://github.com/cloudhead/nakamoto.git", rev = "14902d3d5cc9442cdda82419f0f24277d86b243b", optional = true }
+
 # Platform-specific dependencies
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 tokio = { version = "1", features = ["rt", "macros"] }
@@ -55,7 +59,7 @@ verify = ["bitcoinconsensus"]
 default = ["key-value-db", "electrum"]
 sqlite = ["rusqlite", "ahash"]
 sqlite-bundled = ["sqlite", "rusqlite/bundled"]
-compact_filters = ["rocksdb", "socks", "cc"]
+compact_filters = ["rocksdb", "socks", "cc", "nakamoto"]
 key-value-db = ["sled"]
 all-keys = ["keys-bip39"]
 keys-bip39 = ["bip39"]
@@ -93,6 +97,7 @@ reqwest-default-tls = ["esplora-client/async-https"]
 test-blockchains = ["bitcoincore-rpc", "electrum-client"]
 test-electrum = ["electrum", "electrsd/electrs_0_8_10", "electrsd/bitcoind_22_0", "test-blockchains"]
 test-rpc = ["rpc", "electrsd/electrs_0_8_10", "electrsd/bitcoind_22_0", "test-blockchains"]
+test-cbf = ["compact_filters", "electrsd/electrs_0_8_10", "electrsd/bitcoind_22_0", "test-blockchains"]
 test-rpc-legacy = ["rpc", "electrsd/electrs_0_8_10", "electrsd/bitcoind_0_20_0", "test-blockchains"]
 test-esplora = ["electrsd/legacy", "electrsd/esplora_a33e97e1", "electrsd/bitcoind_22_0", "test-blockchains"]
 test-md-docs = ["electrum"]
diff --git a/src/blockchain/compact_filters/mod.rs b/src/blockchain/compact_filters/mod.rs
index 7845d513d..d88d59620 100644
--- a/src/blockchain/compact_filters/mod.rs
+++ b/src/blockchain/compact_filters/mod.rs
@@ -68,6 +68,8 @@ mod peer;
 mod store;
 mod sync;
 
+pub mod nakamoto;
+
 use crate::blockchain::*;
 use crate::database::{BatchDatabase, BatchOperations, DatabaseUtils};
 use crate::error::Error;
diff --git a/src/blockchain/compact_filters/nakamoto.rs b/src/blockchain/compact_filters/nakamoto.rs
new file mode 100644
index 000000000..6bd544862
--- /dev/null
+++ b/src/blockchain/compact_filters/nakamoto.rs
@@ -0,0 +1,689 @@
+// Bitcoin Dev Kit
+// Written in 2020 by Alekos Filini <alekos.filini@gmail.com>
+//
+// Copyright (c) 2020-2021 Bitcoin Dev Kit Developers
+//
+// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
+// or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
+// You may not use this file except in accordance with one or both of these
+// licenses.
+
+//! This is Compact Filter (BIP157) Blockchain implementation using the nakamoto crate.
+//! https://github.com/cloudhead/nakamoto
+//!
+//! This module implements BDK's [crate::blockchain::Blockchain] trait over a nakamoto
+//! client. Which is it's own state machine that maintains the compact filter database
+//! and interface with the Bitcoin p2p network using the BIP157/BIP158 protocol.
+#![allow(dead_code)]
+
+use crate::blockchain::{
+    Blockchain, Capability, ConfigurableBlockchain, GetBlockHash, GetHeight, GetTx, WalletSync,
+};
+use crate::database::{BatchDatabase, BatchOperations, DatabaseUtils};
+use crate::{BlockTime, FeeRate, KeychainKind, LocalUtxo, TransactionDetails};
+use bitcoin::{Block, OutPoint, Script, Transaction, Txid};
+use log::{debug, info};
+use nakamoto::{
+    client::{
+        chan::Receiver, handle::Handle, protocol, protocol::fees::FeeEstimate, spv::TxStatus,
+        Client, Config, Event, Handle as ClientHandle,
+    },
+    net::poll::Waker,
+};
+use std::cell::Cell;
+use std::collections::{HashMap, HashSet};
+use std::net::SocketAddr;
+use std::path::PathBuf;
+use std::time::Duration;
+use std::{net::TcpStream, thread};
+use thiserror::Error;
+
+type Reactor = nakamoto::net::poll::Reactor<TcpStream>;
+
+/// An Error that occurred during the compact block filter operation.
+#[derive(Debug, Error)]
+pub enum CbfError {
+    /// Global BDK error
+    #[error(transparent)]
+    Global(#[from] Box<crate::error::Error>),
+
+    /// Nakamoto client error
+    #[error(transparent)]
+    Nakamoto(#[from] nakamoto::client::error::Error),
+}
+
+impl From<crate::error::Error> for CbfError {
+    fn from(err: crate::error::Error) -> Self {
+        CbfError::Global(Box::new(err))
+    }
+}
+
+/// Process a transaction by looking for inputs that spend from a UTXO in the database or
+/// outputs that send funds to a know script_pubkey.
+fn add_tx(
+    database: &mut impl BatchDatabase,
+    tx: &Transaction,
+    height: Option<u32>,
+    timestamp: Option<u64>,
+    internal_max_deriv: &mut Option<u32>,
+    external_max_deriv: &mut Option<u32>,
+) -> Result<(), CbfError> {
+    let mut updates = database.begin_batch();
+
+    let mut incoming: u64 = 0;
+    let mut outgoing: u64 = 0;
+    let mut inputs_sum: u64 = 0;
+    let mut outputs_sum: u64 = 0;
+
+    // Sanity check for conflicts
+    let db_txs = database.iter_raw_txs()?;
+    let conflicts = db_txs
+        .iter()
+        .filter_map(|existing_tx| {
+            let existing_inputs = existing_tx
+                .input
+                .iter()
+                .map(|txin| txin.previous_output)
+                .collect::<HashSet<_>>();
+            let current_inputs = tx
+                .input
+                .iter()
+                .map(|txin| txin.previous_output)
+                .collect::<HashSet<_>>();
+            if !current_inputs
+                .intersection(&existing_inputs)
+                .collect::<Vec<_>>()
+                .is_empty()
+                && existing_tx.txid() != tx.txid()
+            {
+                Some(existing_tx)
+            } else {
+                None
+            }
+        })
+        .collect::<Vec<_>>();
+
+    for conflict in conflicts {
+        debug!(
+            "{} Conflicts with existing tx {}",
+            tx.txid(),
+            conflict.txid()
+        );
+        // TODO: Make more intelligent checking following RBF rules.
+        if conflict.is_explicitly_rbf() {
+            debug!("{} Replaces {} via RBF", tx.txid(), conflict.txid());
+            // Assuming the latest RBF transaction is the right transaction to keep.
+            // Delete the existing one.
+            delete_tx(database, &conflict.txid())?;
+        } else {
+            debug!(
+                "{} is non-rbf and conflicts with {}. Rejected",
+                tx.txid(),
+                conflict.txid()
+            );
+            return Ok(());
+        }
+    }
+
+    // Process transaction inputs
+    for input in tx.input.iter() {
+        if let Some(previous_output) = database.get_previous_output(&input.previous_output)? {
+            inputs_sum += previous_output.value;
+
+            // this output is ours, we have a path to derive it
+            if let Some((keychain, _)) =
+                database.get_path_from_script_pubkey(&previous_output.script_pubkey)?
+            {
+                outgoing += previous_output.value;
+
+                debug!("{} is mine, setting utxo as spent", input.previous_output);
+                updates.set_utxo(&LocalUtxo {
+                    outpoint: input.previous_output,
+                    txout: previous_output.clone(),
+                    keychain,
+                    is_spent: true,
+                })?;
+            }
+        }
+    }
+
+    // Process transaction outputs
+    for (i, output) in tx.output.iter().enumerate() {
+        outputs_sum += output.value;
+
+        // When the output is ours
+        if let Some((keychain, child)) =
+            database.get_path_from_script_pubkey(&output.script_pubkey)?
+        {
+            debug!("{} output #{} is mine, adding utxo", tx.txid(), i);
+            updates.set_utxo(&LocalUtxo {
+                outpoint: OutPoint::new(tx.txid(), i as u32),
+                txout: output.clone(),
+                keychain,
+                is_spent: false,
+            })?;
+            incoming += output.value;
+
+            if keychain == KeychainKind::Internal
+                && (internal_max_deriv.is_none() || child > internal_max_deriv.unwrap_or(0))
+            {
+                *internal_max_deriv = Some(child);
+            } else if keychain == KeychainKind::External
+                && (external_max_deriv.is_none() || child > external_max_deriv.unwrap_or(0))
+            {
+                *external_max_deriv = Some(child);
+            }
+        }
+    }
+
+    if incoming > 0 || outgoing > 0 {
+        let tx = TransactionDetails {
+            txid: tx.txid(),
+            transaction: Some(tx.clone()),
+            received: incoming,
+            sent: outgoing,
+            confirmation_time: BlockTime::new(height, timestamp),
+            fee: Some(inputs_sum.saturating_sub(outputs_sum)),
+        };
+
+        debug!("Saving tx {}", tx.txid);
+        updates.set_tx(&tx)?;
+    }
+
+    database.commit_batch(updates)?;
+
+    Ok(())
+}
+
+/// Mark as transaction as unconfirmed in the database.
+/// This is called in block reorg cases, where previously confirmed transactions becomes unconfirmed.
+fn unconfirm_tx(
+    database: &mut impl BatchDatabase,
+    txid: &Txid,
+) -> Result<TransactionDetails, CbfError> {
+    let mut tx_details = database
+        .get_tx(&txid, false)?
+        .expect("We must have the transaction at this stage");
+    tx_details.confirmation_time = None;
+    database.set_tx(&tx_details)?;
+    debug!("Existing transaction marked unconfirmed : {}", txid);
+    Ok(tx_details)
+}
+
+/// Delete a Transaction from the database, updating related UTXO records.
+/// This is called in a a RBF case.
+fn delete_tx(database: &mut impl BatchDatabase, txid: &Txid) -> Result<(), CbfError> {
+    let mut updates = database.begin_batch();
+
+    if let Some(db_tx) = database.get_raw_tx(txid)? {
+        let txid = db_tx.txid();
+        // Mark input utxos as unspent
+        for input in db_tx.input {
+            let prev_output = input.previous_output;
+            if let Some(mut existing_utxo) = database.get_utxo(&prev_output)? {
+                debug!("Setting UTXO : {} as `unspent`", existing_utxo.outpoint);
+                existing_utxo.is_spent = false;
+                updates.set_utxo(&existing_utxo)?;
+            }
+        }
+
+        // Delete output utxos
+        for (i, _) in db_tx.output.iter().enumerate() {
+            let outpoint = OutPoint::new(txid, i as u32);
+            if let Some(deleted_utxo) = updates.del_utxo(&outpoint)? {
+                debug!("Deleting Existing UTXO {}", deleted_utxo.outpoint);
+            }
+        }
+
+        // Delete the transaction data
+        let _ = database
+            .del_tx(&txid, true)?
+            .expect("We must have the transaction at this stage")
+            .txid;
+        debug!("Deleting existing transaction : txid: {}", txid);
+    }
+
+    database.commit_batch(updates)?;
+
+    Ok(())
+}
+
+/// Structure containing the nakamoto client handle and event receiver.
+pub struct CbfBlockchain {
+    /// A Receiver of all client related events
+    receiver: Receiver<Event>,
+    /// The handler for the client
+    client_handle: ClientHandle<Waker>,
+    /// Internal query timeout. Set by default at 60 secs.
+    timeout: Duration,
+    /// A store of blockheight and fee estimation
+    fee_data: Cell<HashMap<u32, FeeEstimate>>,
+    /// A local cache of unconfirmed broadcasted transactions.
+    /// Used to sync wallet db with known unconfirmed txs. Cleared at each `wallet.sync()` call.
+    broadcasted_txs: Cell<Vec<Transaction>>,
+    /// Last Sync height
+    last_sync_height: Cell<u32>,
+    // A Hack to handle reorg sync cases.
+    #[cfg(test)]
+    break_sync_at: Cell<Option<u32>>,
+}
+
+/// Nakamoto CBF Client Configuration
+#[derive(Debug, Clone, PartialEq, Eq, serde::Deserialize, serde::Serialize)]
+pub struct CBFBlockchainConfig {
+    /// Network for the CBF client
+    pub network: bitcoin::Network,
+    /// Optional custom datadir for CBF Client
+    pub datadir: Option<PathBuf>,
+}
+
+impl CbfBlockchain {
+    /// Create a new CBF node which runs at the background.
+    pub fn new(network: bitcoin::Network, datadir: Option<PathBuf>) -> Result<Self, CbfError> {
+        let root = if let Some(dir) = datadir {
+            dir
+        } else {
+            PathBuf::from(std::env::var("HOME").unwrap_or_default())
+        };
+        let cbf_client = Client::<Reactor>::new()?;
+        let client_cfg = Config {
+            listen: vec![], // Don't listen for incoming connections.
+            root,
+            protocol: protocol::Config {
+                network: network.into(),
+                ..protocol::Config::default()
+            },
+            ..Config::default()
+        };
+
+        let client_handle = cbf_client.handle();
+        thread::spawn(|| {
+            cbf_client.run(client_cfg).unwrap();
+        });
+        let receiver = client_handle.subscribe();
+
+        Ok(Self {
+            receiver,
+            client_handle,
+            timeout: Duration::from_secs(60), // This is nakamoto default client timeout
+            fee_data: Cell::new(HashMap::new()),
+            broadcasted_txs: Cell::new(Vec::new()),
+            last_sync_height: Cell::new(0u32),
+            #[cfg(test)]
+            break_sync_at: Cell::new(None),
+        })
+    }
+
+    /// Scan the filters from a height, for a given list of scripts
+    pub fn scan(&self, from: u32, scripts: Vec<Script>) {
+        let _ = self
+            .client_handle
+            .rescan((from as u64).., scripts.into_iter());
+    }
+
+    /// Add fee estimation data, in the fee estimation store
+    fn add_fee_data(&self, height: u32, fee_estimate: FeeEstimate) {
+        let mut data = self.fee_data.take();
+        data.insert(height, fee_estimate);
+        self.fee_data.set(data)
+    }
+
+    /// Connect the client with a specific peer.
+    pub fn add_peers(&self, peers: Vec<SocketAddr>) -> Result<Vec<SocketAddr>, CbfError> {
+        let mut connected_peers = vec![];
+        for peer in peers {
+            let _ = self
+                .client_handle
+                .connect(peer)
+                .map_err(nakamoto::client::Error::from)?;
+            connected_peers.push(peer);
+        }
+        Ok(connected_peers)
+    }
+
+    /// Disconnect the client from a specific peer
+    pub fn diconnect(&self, peer: SocketAddr) {
+        self.client_handle.disconnect(peer).unwrap();
+    }
+
+    /// Broadcast a transaction to the p2p network
+    fn braodcast(&self, tx: Transaction) -> Result<(), CbfError> {
+        debug!("Broadcasting txid : {}", tx.txid(),);
+        let socket = self
+            .client_handle
+            .submit_transaction(tx.clone())
+            .map_err(nakamoto::client::Error::from)?;
+        debug!("Broacasted to : {:?}", socket);
+        // Add the tx to the broadcasted list
+        let mut broadcasted = self.broadcasted_txs.take();
+        broadcasted.push(tx);
+        self.broadcasted_txs.set(broadcasted);
+
+        Ok(())
+    }
+
+    /// Read the next event received from event listener
+    pub fn get_next_event(&self) -> Result<Event, CbfError> {
+        Ok(self
+            .receiver
+            .recv()
+            .map_err(|e| nakamoto::client::Error::from(nakamoto::client::handle::Error::from(e)))?)
+    }
+
+    /// Shutdown the client
+    pub fn shutdown(self) {
+        self.client_handle.shutdown().unwrap();
+    }
+
+    /// Get a Block from the p2p network given a height
+    pub fn get_block(&self, height: u32) -> Result<Option<Block>, CbfError> {
+        if let Some(header) = self
+            .client_handle
+            .get_block_by_height(height as u64)
+            .map_err(nakamoto::client::Error::from)?
+        {
+            self.client_handle
+                .get_block(&header.block_hash())
+                .map_err(nakamoto::client::Error::from)?;
+
+            let receiver = self.client_handle.blocks();
+
+            let block;
+            loop {
+                let (new_block, blk_height) = receiver.recv().map_err(|e| {
+                    nakamoto::client::Error::from(nakamoto::client::handle::Error::from(e))
+                })?;
+                if blk_height as u32 == height {
+                    block = new_block;
+                    break;
+                }
+            }
+
+            Ok(Some(block))
+        } else {
+            Ok(None)
+        }
+    }
+
+    #[cfg(test)]
+    pub fn set_break_sync_height(&self, ht: u32) {
+        let height = Some(ht);
+        self.break_sync_at.set(height);
+    }
+}
+
+impl Blockchain for CbfBlockchain {
+    fn get_capabilities(&self) -> HashSet<Capability> {
+        vec![Capability::FullHistory].into_iter().collect()
+    }
+
+    fn broadcast(&self, tx: &Transaction) -> Result<(), crate::Error> {
+        self.braodcast(tx.clone())?;
+        Ok(())
+    }
+
+    // TODO: Improve Fee estimation
+    fn estimate_fee(&self, _target: usize) -> Result<FeeRate, crate::Error> {
+        // Return the last known fee estimation
+        let fee_data = self.fee_data.take();
+        let last_block_fee_rate = fee_data
+            .iter()
+            .last()
+            .map(|(_, estimate)| {
+                let median_rate = FeeRate::from_sat_per_vb(estimate.median as f32);
+                median_rate
+            })
+            .expect("Some value expected");
+        self.fee_data.set(fee_data);
+        Ok(last_block_fee_rate)
+    }
+}
+
+impl GetBlockHash for CbfBlockchain {
+    fn get_block_hash(&self, height: u64) -> Result<bitcoin::BlockHash, crate::Error> {
+        let header = self
+            .client_handle
+            .get_block_by_height(height)
+            .map_err(nakamoto::client::Error::from)
+            .map_err(CbfError::from)?
+            .expect("Block at given height doesn't exist");
+        Ok(header.block_hash())
+    }
+}
+
+impl GetTx for CbfBlockchain {
+    fn get_tx(&self, _txid: &Txid) -> Result<Option<Transaction>, crate::Error> {
+        Ok(None)
+    }
+}
+
+impl GetHeight for CbfBlockchain {
+    fn get_height(&self) -> Result<u32, crate::Error> {
+        Ok(self
+            .client_handle
+            .get_tip()
+            .map_err(nakamoto::client::Error::from)
+            .map_err(CbfError::from)?
+            .0 as u32)
+    }
+}
+
+impl WalletSync for CbfBlockchain {
+    fn wallet_setup<D: BatchDatabase>(
+        &self,
+        database: &mut D,
+        progress_update: Box<dyn crate::blockchain::Progress>,
+    ) -> Result<(), crate::Error> {
+        let db_scripts = database.iter_script_pubkeys(None)?;
+        self.client_handle
+            .watch(db_scripts.iter().cloned())
+            .map_err(nakamoto::client::Error::from)
+            .map_err(CbfError::from)?;
+
+        // Rescan from previous block of last_sync_height, to trigger the event loop.
+        self.scan(self.last_sync_height.get().saturating_sub(1), db_scripts);
+
+        let mut internal_max_deriv = None;
+        let mut external_max_deriv = None;
+
+        // Add all broadcasted transactions to db
+        for tx in self.broadcasted_txs.take().iter() {
+            debug!("Processing braodcasted transaction : {}", tx.txid());
+            add_tx(
+                database,
+                tx,
+                None,
+                None,
+                &mut internal_max_deriv,
+                &mut external_max_deriv,
+            )?;
+        }
+
+        loop {
+            // TODO: Investigate why this is causing error
+            // if self.last_sync_height.get() == self.get_height()? {
+            //     break;
+            // }
+            match self.get_next_event()? {
+                Event::BlockConnected { hash, height, .. } => {
+                    debug!("New Block Found : {} at {}", hash, height);
+                }
+                // Event::BlockDisconnected { height, .. } => {
+                //     let db_txs = database
+                //         .iter_txs(false)?
+                //         .iter()
+                //         .filter_map(|tx_details| {
+                //             if let Some(block_time) = &tx_details.confirmation_time {
+                //                 if block_time.height == height as u32 {
+                //                     Some(tx_details.txid)
+                //                 } else {
+                //                     None
+                //                 }
+                //             } else {
+                //                 None
+                //             }
+                //         })
+                //         .collect::<HashSet<_>>();
+
+                //     for txid in db_txs {
+                //         unconfirm_tx(database, &txid)?;
+                //     }
+                // }
+                Event::BlockMatched {
+                    hash: _,
+                    header,
+                    height,
+                    transactions,
+                } => {
+                    let timestamp = header.time;
+                    for tx in transactions {
+                        // Check that we haven't processed this transaction before
+                        if database
+                            .iter_txs(false)?
+                            .iter()
+                            .find(|detail| {
+                                detail.txid == tx.txid()
+                                    && detail.confirmation_time.as_ref().map(|bt| bt.height)
+                                        == Some(height as u32)
+                            })
+                            .is_none()
+                        {
+                            debug!(
+                                "Processing Confirmed Transaction : {} at Block : {}",
+                                tx.txid(),
+                                height
+                            );
+                            add_tx(
+                                database,
+                                &tx,
+                                Some(height as u32),
+                                Some(timestamp as u64),
+                                &mut internal_max_deriv,
+                                &mut external_max_deriv,
+                            )?;
+                        }
+                    }
+                }
+                Event::FeeEstimated { height, fees, .. } => {
+                    self.add_fee_data(height as u32, fees);
+                }
+                Event::TxStatusChanged { txid, status } => {
+                    match status {
+                        TxStatus::Unconfirmed => {
+                            debug!("txid:{}, status : Broadcasted", txid);
+                        }
+                        TxStatus::Acknowledged { peer } => {
+                            debug!("txid: {}, status : ACK by {}", txid, peer);
+                        }
+                        TxStatus::Confirmed { height, .. } => {
+                            debug!("txid: {}, status : Confirmed at {}", txid, height);
+                        }
+                        TxStatus::Reverted => {
+                            debug!("Transaction reverted due to reorg: txid : {}", txid);
+                            let _ = unconfirm_tx(database, &txid)?;
+                        }
+                        TxStatus::Stale { replaced_by, block } => {
+                            debug!(
+                                "txid: {}, status : Replaced by : txid {} at blockhash {}",
+                                txid, replaced_by, block
+                            );
+                            let tx = database.get_tx(&replaced_by, true)?.expect(
+                                "Wallet transaction got replaced by unknown foreign transaction",
+                            ); // TODO: Handle the case when we don't have the overriding transaction
+                            delete_tx(database, &tx.txid)?;
+                        }
+                    }
+                }
+                Event::Synced { height, tip } => {
+                    debug!("Sync Status : {}:{}", height, tip);
+                    progress_update.update(
+                        (height as f32 / tip as f32) * 100.0,
+                        Some("Sync Progress".into()),
+                    )?;
+                    // We break the sync loop once we reach current height.
+                    if height == tip {
+                        debug!("Sync complete at : {}", height);
+                        self.last_sync_height.set(height as u32);
+                        break;
+                    }
+                    // Check for force stop signal
+                    #[cfg(test)]
+                    {
+                        if let Some(break_height) = self.break_sync_at.get() {
+                            if break_height == height as u32 {
+                                debug!("Force breaking sync at : {}", height);
+                                self.last_sync_height.set(height as u32);
+                                break;
+                            }
+                        }
+                    }
+                }
+                _ => { /* Rest of the Events are unused */ }
+            }
+        }
+
+        // Set External Last index after sync
+        let current_ext = database
+            .get_last_index(KeychainKind::External)?
+            .unwrap_or(0);
+        let first_ext_new = external_max_deriv.unwrap_or(0);
+        if first_ext_new > current_ext {
+            debug!("Setting external index to {}", first_ext_new);
+            database.set_last_index(KeychainKind::External, first_ext_new)?;
+        }
+
+        // Set Internal Last index after sync
+        let current_int = database
+            .get_last_index(KeychainKind::Internal)?
+            .unwrap_or(0);
+        let first_int_new = internal_max_deriv.unwrap_or(0);
+        if first_int_new > current_int {
+            info!("Setting internal index to {}", first_int_new);
+            database.set_last_index(KeychainKind::Internal, first_int_new)?;
+        }
+
+        Ok(())
+    }
+}
+
+impl ConfigurableBlockchain for CbfBlockchain {
+    type Config = CBFBlockchainConfig;
+
+    fn from_config(config: &Self::Config) -> Result<Self, crate::Error> {
+        Ok(Self::new(config.network, config.datadir.clone())?)
+    }
+}
+
+#[cfg(test)]
+#[cfg(feature = "test-cbf")]
+mod test {
+    use super::*;
+    use bitcoincore_rpc::RpcApi;
+
+    crate::bdk_blockchain_tests! {
+        fn test_instance(test_client: &TestClient) -> CbfBlockchain {
+            // Hack : Get the middle portion of a random address string to create test specific
+            // unique temp directory.
+            let addrs = &test_client
+                .bitcoind
+                .client
+                .get_new_address(None, None)
+                .unwrap()
+                .to_string()[10..15];
+
+            let mut root = std::env::temp_dir();
+            root = root.join(addrs);
+            let cbf_node = CbfBlockchain::new(Network::Regtest, Some(root)).unwrap();
+
+            let bitcoind_p2p_port = test_client
+                .bitcoind
+                .params
+                .p2p_socket
+                .expect("Bitcoin P2P Port should be available");
+            cbf_node.add_peers(vec![bitcoind_p2p_port.into()]).unwrap();
+
+            cbf_node
+        }
+    }
+}
diff --git a/src/error.rs b/src/error.rs
index fba0fd2d7..0959c60f8 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -138,6 +138,9 @@ pub enum Error {
     #[cfg(feature = "compact_filters")]
     /// Compact filters client error)
     CompactFilters(crate::blockchain::compact_filters::CompactFiltersError),
+    #[cfg(feature = "compact_filters")]
+    /// CBF nakamoto error
+    Cbf(crate::blockchain::compact_filters::nakamoto::CbfError),
     #[cfg(feature = "key-value-db")]
     /// Sled database error
     Sled(sled::Error),
@@ -330,6 +333,16 @@ impl From<crate::blockchain::compact_filters::CompactFiltersError> for Error {
     }
 }
 
+#[cfg(feature = "compact_filters")]
+impl From<crate::blockchain::compact_filters::nakamoto::CbfError> for Error {
+    fn from(other: crate::blockchain::compact_filters::nakamoto::CbfError) -> Self {
+        match other {
+            crate::blockchain::compact_filters::nakamoto::CbfError::Global(e) => *e,
+            err => Error::Cbf(err),
+        }
+    }
+}
+
 #[cfg(feature = "verify")]
 impl From<crate::wallet::verify::VerifyError> for Error {
     fn from(other: crate::wallet::verify::VerifyError) -> Self {

From 48b37579f77322c20dd25da3db85d1d3a3f1fd6b Mon Sep 17 00:00:00 2001
From: rajarshimaitra <rajarshi149@gmail.com>
Date: Sat, 8 Oct 2022 22:53:36 +0530
Subject: [PATCH 2/6] Add nakamoto into blockchain test

This commit adds the nakamoto blockchain into the current blockchain test
frameworks. Uses a lot of feature gate and scaffolding to handle special
behaviors of CBF type backend.
---
 src/blockchain/rpc.rs             |   2 +-
 src/testutils/blockchain_tests.rs | 213 ++++++++++++++++++++++++------
 2 files changed, 171 insertions(+), 44 deletions(-)

diff --git a/src/blockchain/rpc.rs b/src/blockchain/rpc.rs
index da19e20c6..076437f96 100644
--- a/src/blockchain/rpc.rs
+++ b/src/blockchain/rpc.rs
@@ -983,7 +983,7 @@ mod test {
                 let txid =
                     test_client.receive(testutils! { @tx ( (@addr addr) => AMOUNT_PER_TX ) });
                 test_client.generate(1, None);
-                txid
+                txid.txid()
             })
             .collect::<Vec<_>>();
 
diff --git a/src/testutils/blockchain_tests.rs b/src/testutils/blockchain_tests.rs
index a048802e0..46214127d 100644
--- a/src/testutils/blockchain_tests.rs
+++ b/src/testutils/blockchain_tests.rs
@@ -36,6 +36,19 @@ impl TestClient {
         debug!("launching {} and {}", &bitcoind_exe, &electrs_exe);
 
         let mut conf = bitcoind::Conf::default();
+        #[cfg(feature = "test-cbf")]
+        {
+            conf.args.extend(vec![
+                "-blockfilterindex=1",
+                "-peerblockfilters",
+                "-txindex",
+                "-debug=net",
+                "-debug=mempool",
+                "-debug=mempoolrej",
+                "-debug=rpc",
+            ]);
+            conf.p2p = bitcoind::P2P::Yes;
+        }
         conf.view_stdout = log_enabled!(Level::Debug);
         let bitcoind = BitcoinD::with_conf(bitcoind_exe, &conf).unwrap();
 
@@ -56,7 +69,7 @@ impl TestClient {
         test_client
     }
 
-    fn wait_for_tx(&mut self, txid: Txid, monitor_script: &Script) {
+    pub fn wait_for_tx(&mut self, txid: Txid, monitor_script: &Script) {
         // wait for electrs to index the tx
         exponential_backoff_poll(|| {
             self.electrsd.trigger().unwrap();
@@ -71,7 +84,19 @@ impl TestClient {
         });
     }
 
-    fn wait_for_block(&mut self, min_height: usize) {
+    // Wait for a transaction to appear in bitcoind's mempool
+    // This is useful for CBF tests, as it takes some time for
+    // broadcasted transactions to appear in the mempool
+    pub fn wait_for_tx_in_mempool(&self, txid: &Txid) {
+        exponential_backoff_poll(|| {
+            self.get_raw_mempool()
+                .unwrap()
+                .iter()
+                .position(|mem_txid| mem_txid == txid)
+        });
+    }
+
+    fn wait_for_block(&self, min_height: usize) {
         self.electrsd.client.block_headers_subscribe().unwrap();
 
         loop {
@@ -86,7 +111,7 @@ impl TestClient {
         }
     }
 
-    pub fn receive(&mut self, meta_tx: TestIncomingTx) -> Txid {
+    pub fn receive(&mut self, meta_tx: TestIncomingTx) -> Transaction {
         assert!(
             !meta_tx.output.is_empty(),
             "can't create a transaction with no outputs"
@@ -148,10 +173,10 @@ impl TestClient {
 
         debug!("Sent tx: {}", txid);
 
-        txid
+        deserialize::<Transaction>(&tx.hex).unwrap()
     }
 
-    pub fn bump_fee(&mut self, txid: &Txid) -> Txid {
+    pub fn bump_fee(&mut self, txid: &Txid) -> Transaction {
         let tx = self.get_raw_transaction_info(txid, None).unwrap();
         assert!(
             tx.confirmations.is_none(),
@@ -166,7 +191,7 @@ impl TestClient {
 
         debug!("Bumped {}, new txid {}", txid, new_txid);
 
-        new_txid
+        deserialize::<Transaction>(&tx.hex).unwrap()
     }
 
     pub fn generate_manually(&mut self, txs: Vec<Transaction>) -> String {
@@ -454,8 +479,10 @@ macro_rules! bdk_blockchain_tests {
                 let tx = testutils! {
                     @tx ( (@external descriptors, 0) => 50_000 )
                 };
-                println!("{:?}", tx);
-                let txid = test_client.receive(tx);
+                let tx = test_client.receive(tx);
+                let txid = tx.txid();
+                #[cfg(feature = "test-cbf")]
+                let _ = blockchain.broadcast(&tx).unwrap();
 
                 // the RPC blockchain needs to call `sync()` during initialization to import the
                 // addresses (see `init_single_sig()`), so we skip this assertion
@@ -479,12 +506,16 @@ macro_rules! bdk_blockchain_tests {
             fn test_sync_stop_gap_20() {
                 let (wallet, blockchain, descriptors, mut test_client) = init_single_sig();
 
-                test_client.receive(testutils! {
+                let tx = test_client.receive(testutils! {
                     @tx ( (@external descriptors, 5) => 50_000 )
                 });
-                test_client.receive(testutils! {
+                #[cfg(feature = "test-cbf")]
+                let _ = blockchain.broadcast(&tx).unwrap();
+                let tx = test_client.receive(testutils! {
                     @tx ( (@external descriptors, 25) => 50_000 )
                 });
+                #[cfg(feature = "test-cbf")]
+                let _ = blockchain.broadcast(&tx).unwrap();
 
                 wallet.sync(&blockchain, SyncOptions::default()).unwrap();
 
@@ -499,9 +530,11 @@ macro_rules! bdk_blockchain_tests {
                 wallet.sync(&blockchain, SyncOptions::default()).unwrap();
                 assert_eq!(wallet.get_balance().unwrap().get_total(), 0);
 
-                test_client.receive(testutils! {
+                let tx = test_client.receive(testutils! {
                     @tx ( (@external descriptors, 0) => 50_000 )
                 });
+                #[cfg(feature = "test-cbf")]
+                let _ = blockchain.broadcast(&tx).unwrap();
 
                 wallet.sync(&blockchain, SyncOptions::default()).unwrap();
 
@@ -521,9 +554,12 @@ macro_rules! bdk_blockchain_tests {
             fn test_sync_multiple_outputs_same_tx() {
                 let (wallet, blockchain, descriptors, mut test_client) = init_single_sig();
 
-                let txid = test_client.receive(testutils! {
+                let tx = test_client.receive(testutils! {
                     @tx ( (@external descriptors, 0) => 50_000, (@external descriptors, 1) => 25_000, (@external descriptors, 5) => 30_000 )
                 });
+                let txid = tx.txid();
+                let _ = blockchain.broadcast(&tx).unwrap();
+
 
                 wallet.sync(&blockchain, SyncOptions::default()).unwrap();
 
@@ -542,12 +578,16 @@ macro_rules! bdk_blockchain_tests {
             fn test_sync_receive_multi() {
                 let (wallet, blockchain, descriptors, mut test_client) = init_single_sig();
 
-                test_client.receive(testutils! {
+                let tx = test_client.receive(testutils! {
                     @tx ( (@external descriptors, 0) => 50_000 )
                 });
-                test_client.receive(testutils! {
+                #[cfg(feature = "test-cbf")]
+                let _ = blockchain.broadcast(&tx).unwrap();
+                let tx = test_client.receive(testutils! {
                     @tx ( (@external descriptors, 5) => 25_000 )
                 });
+                #[cfg(feature = "test-cbf")]
+                let _ = blockchain.broadcast(&tx).unwrap();
 
                 wallet.sync(&blockchain, SyncOptions::default()).unwrap();
 
@@ -560,16 +600,20 @@ macro_rules! bdk_blockchain_tests {
             fn test_sync_address_reuse() {
                 let (wallet, blockchain, descriptors, mut test_client) = init_single_sig();
 
-                test_client.receive(testutils! {
+                let tx = test_client.receive(testutils! {
                     @tx ( (@external descriptors, 0) => 50_000 )
                 });
+                #[cfg(feature = "test-cbf")]
+                let _ = blockchain.broadcast(&tx).unwrap();
 
                 wallet.sync(&blockchain, SyncOptions::default()).unwrap();
                 assert_eq!(wallet.get_balance().unwrap().untrusted_pending, 50_000);
 
-                test_client.receive(testutils! {
+                let tx = test_client.receive(testutils! {
                     @tx ( (@external descriptors, 0) => 25_000 )
                 });
+                #[cfg(feature = "test-cbf")]
+                let _ = blockchain.broadcast(&tx).unwrap();
 
                 wallet.sync(&blockchain, SyncOptions::default()).unwrap();
                 assert_eq!(wallet.get_balance().unwrap().untrusted_pending, 75_000, "incorrect balance");
@@ -579,9 +623,12 @@ macro_rules! bdk_blockchain_tests {
             fn test_sync_receive_rbf_replaced() {
                 let (wallet, blockchain, descriptors, mut test_client) = init_single_sig();
 
-                let txid = test_client.receive(testutils! {
+                let tx = test_client.receive(testutils! {
                     @tx ( (@external descriptors, 0) => 50_000 ) ( @replaceable true )
                 });
+                let txid = tx.txid();
+                #[cfg(feature = "test-cbf")]
+                let _ = blockchain.broadcast(&tx).unwrap();
 
                 wallet.sync(&blockchain, SyncOptions::default()).unwrap();
 
@@ -595,7 +642,10 @@ macro_rules! bdk_blockchain_tests {
                 assert_eq!(list_tx_item.sent, 0, "incorrect sent");
                 assert_eq!(list_tx_item.confirmation_time, None, "incorrect confirmation_time");
 
-                let new_txid = test_client.bump_fee(&txid);
+                let new_tx = test_client.bump_fee(&txid);
+                let new_txid = new_tx.txid();
+                #[cfg(feature = "test-cbf")]
+                let _ = blockchain.broadcast(&new_tx).unwrap();
 
                 wallet.sync(&blockchain, SyncOptions::default()).unwrap();
 
@@ -617,9 +667,10 @@ macro_rules! bdk_blockchain_tests {
             fn test_sync_reorg_block() {
                 let (wallet, blockchain, descriptors, mut test_client) = init_single_sig();
 
-                let txid = test_client.receive(testutils! {
+                let tx = test_client.receive(testutils! {
                     @tx ( (@external descriptors, 0) => 50_000 ) ( @confirmations 1 ) ( @replaceable true )
                 });
+                let txid = tx.txid();
 
                 wallet.sync(&blockchain, SyncOptions::default()).unwrap();
                 assert_eq!(wallet.get_balance().unwrap().get_spendable(), 50_000, "incorrect balance");
@@ -633,6 +684,9 @@ macro_rules! bdk_blockchain_tests {
                 // Invalidate 1 block
                 test_client.invalidate(1);
 
+                #[cfg(feature = "test-cbf")]
+                blockchain.set_break_sync_height(test_client.get_blockchain_info().unwrap().blocks as u32); // Manually set the break height.
+
                 wallet.sync(&blockchain, SyncOptions::default()).unwrap();
 
                 assert_eq!(wallet.get_balance().unwrap().untrusted_pending, 50_000, "incorrect balance after invalidate");
@@ -648,9 +702,11 @@ macro_rules! bdk_blockchain_tests {
                                 println!("{}", descriptors.0);
                 let node_addr = test_client.get_node_address(None);
 
-                test_client.receive(testutils! {
+                let tx = test_client.receive(testutils! {
                     @tx ( (@external descriptors, 0) => 50_000 )
                 });
+                #[cfg(feature = "test-cbf")]
+                let _ = blockchain.broadcast(&tx).unwrap();
 
                 wallet.sync(&blockchain, SyncOptions::default()).unwrap();
                 assert_eq!(wallet.get_balance().unwrap().untrusted_pending, 50_000, "incorrect balance");
@@ -663,6 +719,8 @@ macro_rules! bdk_blockchain_tests {
                 let tx = psbt.extract_tx();
                 println!("{}", bitcoin::consensus::encode::serialize_hex(&tx));
                 blockchain.broadcast(&tx).unwrap();
+                #[cfg(festure = "test-cbf")]
+                test_client.wait_for_tx_in_mempool(tx.txid());
                 wallet.sync(&blockchain, SyncOptions::default()).unwrap();
                 assert_eq!(wallet.get_balance().unwrap().trusted_pending, details.received, "incorrect balance after send");
 
@@ -695,9 +753,11 @@ macro_rules! bdk_blockchain_tests {
                     assert_eq!(new_addr.index, i+first_addr_index, "unexpected new address index (before sync)");
 
                     if i < ADDRS_TO_FUND {
-                        test_client.receive(testutils! {
+                        let tx = test_client.receive(testutils! {
                             @tx ((@addr new_addr.address) => 50_000)
                         });
+                        #[cfg(feature = "test-cbf")]
+                        let _ = blockchain.broadcast(&tx).unwrap();
                     }
                 });
 
@@ -718,9 +778,11 @@ macro_rules! bdk_blockchain_tests {
 
                 // "secretly" fund wallet via given range
                 (START_FUND..END_FUND).for_each(|addr_index| {
-                    test_client.receive(testutils! {
+                    let tx = test_client.receive(testutils! {
                         @tx ((@external descriptors, addr_index) => 50_000)
                     });
+                    #[cfg(feature = "test-cbf")]
+                    let _ = blockchain.broadcast(&tx).unwrap();
                 });
 
                 wallet.sync(&blockchain, SyncOptions::default()).unwrap();
@@ -737,8 +799,8 @@ macro_rules! bdk_blockchain_tests {
                 let receiver_wallet = get_wallet_from_descriptors(&("wpkh(cVpPVruEDdmutPzisEsYvtST1usBR3ntr8pXSyt6D2YYqXRyPcFW)".to_string(), None));
                 // need to sync so rpc can start watching
                 receiver_wallet.sync(&blockchain, SyncOptions::default()).unwrap();
-
-                test_client.receive(testutils! {
+                wallet.sync(&blockchain, SyncOptions::default()).expect("sync");
+                let _ = test_client.receive(testutils! {
                     @tx ( (@external descriptors, 0) => 50_000, (@external descriptors, 1) => 25_000 ) (@confirmations 1)
                 });
 
@@ -786,9 +848,11 @@ macro_rules! bdk_blockchain_tests {
 
                 // add some to the mempool as well.
                 for _ in 0..20 {
-                    test_client.receive(testutils! {
+                    let tx = test_client.receive(testutils! {
                         @tx ( (@external descriptors, 0) => 1_000 )
                     });
+                    #[cfg(feature = "test-cbf")]
+                    let _ = blockchain.broadcast(&tx).unwrap();
                 }
 
                 wallet.sync(&blockchain, SyncOptions::default()).unwrap();
@@ -800,12 +864,14 @@ macro_rules! bdk_blockchain_tests {
             #[test]
             fn test_update_confirmation_time_after_generate() {
                 let (wallet, blockchain, descriptors, mut test_client) = init_single_sig();
-                                println!("{}", descriptors.0);
                 let node_addr = test_client.get_node_address(None);
 
-                let received_txid = test_client.receive(testutils! {
+                let tx = test_client.receive(testutils! {
                     @tx ( (@external descriptors, 0) => 50_000 )
                 });
+                let received_txid = tx.txid();
+                #[cfg(feature = "test-cbf")]
+                let _ = blockchain.broadcast(&tx).unwrap();
 
                 wallet.sync(&blockchain, SyncOptions::default()).unwrap();
                 assert_eq!(wallet.get_balance().unwrap().untrusted_pending, 50_000, "incorrect balance");
@@ -827,9 +893,12 @@ macro_rules! bdk_blockchain_tests {
             fn test_sync_outgoing_from_scratch() {
                 let (wallet, blockchain, descriptors, mut test_client) = init_single_sig();
                                 let node_addr = test_client.get_node_address(None);
-                let received_txid = test_client.receive(testutils! {
+                let tx = test_client.receive(testutils! {
                     @tx ( (@external descriptors, 0) => 50_000 )
                 });
+                let received_txid = tx.txid();
+                #[cfg(feature = "test-cbf")]
+                let _ = blockchain.broadcast(&tx).unwrap();
 
                 wallet.sync(&blockchain, SyncOptions::default()).unwrap();
                 assert_eq!(wallet.get_balance().unwrap().untrusted_pending, 50_000, "incorrect balance");
@@ -843,13 +912,16 @@ macro_rules! bdk_blockchain_tests {
                 let sent_tx = psbt.extract_tx();
                 blockchain.broadcast(&sent_tx).unwrap();
 
+                #[cfg(feature = "test-cbf")]
+                test_client.wait_for_tx_in_mempool(&sent_tx.txid());
+
                 wallet.sync(&blockchain, SyncOptions::default()).unwrap();
                 assert_eq!(wallet.get_balance().unwrap().get_spendable(), details.received, "incorrect balance after receive");
 
                 // empty wallet
                 let wallet = get_wallet_from_descriptors(&descriptors);
 
-                #[cfg(feature = "rpc")]  // rpc cannot see mempool tx before importmulti
+                #[cfg(any(feature = "rpc", feature = "test-cbf"))]  // rpc cannot see mempool tx before importmulti
                 test_client.generate(1, Some(node_addr));
 
                 wallet.sync(&blockchain, SyncOptions::default()).unwrap();
@@ -870,10 +942,14 @@ macro_rules! bdk_blockchain_tests {
                 let (wallet, blockchain, descriptors, mut test_client) = init_single_sig();
                                 let node_addr = test_client.get_node_address(None);
 
-                test_client.receive(testutils! {
+                let tx = test_client.receive(testutils! {
                     @tx ( (@external descriptors, 0) => 50_000 )
                 });
-
+                #[cfg(feature = "test-cbf")]
+                {
+                    let _ = blockchain.broadcast(&tx).unwrap();
+                    test_client.wait_for_tx_in_mempool(&tx.txid());
+                }
                 wallet.sync(&blockchain, SyncOptions::default()).unwrap();
                 assert_eq!(wallet.get_balance().unwrap().untrusted_pending, 50_000, "incorrect balance");
 
@@ -884,8 +960,12 @@ macro_rules! bdk_blockchain_tests {
                     let (mut psbt, details) = builder.finish().unwrap();
                     let finalized = wallet.sign(&mut psbt, Default::default()).unwrap();
                     assert!(finalized, "Cannot finalize transaction");
-                    blockchain.broadcast(&psbt.extract_tx()).unwrap();
-
+                    let tx = psbt.extract_tx();
+                    #[cfg(feature = "test-cbf")]
+                    {
+                        let _ = blockchain.broadcast(&tx).unwrap();
+                        test_client.wait_for_tx_in_mempool(&tx.txid());
+                    }
                     wallet.sync(&blockchain, SyncOptions::default()).unwrap();
 
                     total_sent += 5_000 + details.fee.unwrap_or(0);
@@ -898,7 +978,7 @@ macro_rules! bdk_blockchain_tests {
 
                 let wallet = get_wallet_from_descriptors(&descriptors);
 
-                #[cfg(feature = "rpc")]  // rpc cannot see mempool tx before importmulti
+                #[cfg(any(feature = "rpc", feature = "test-cbf"))]  // rpc cannot see mempool tx before importmulti
                 test_client.generate(1, Some(node_addr));
 
                 wallet.sync(&blockchain, SyncOptions::default()).unwrap();
@@ -923,7 +1003,10 @@ macro_rules! bdk_blockchain_tests {
                 let (mut psbt, details) = builder.finish().unwrap();
                 let finalized = wallet.sign(&mut psbt, Default::default()).unwrap();
                 assert!(finalized, "Cannot finalize transaction");
-                blockchain.broadcast(&psbt.extract_tx()).unwrap();
+                let tx = &psbt.extract_tx();
+                blockchain.broadcast(&tx).unwrap();
+                #[cfg(feature = "test-cbf")]
+                test_client.wait_for_tx_in_mempool(&tx.txid());
                 wallet.sync(&blockchain, SyncOptions::default()).unwrap();
                 assert_eq!(wallet.get_balance().unwrap().get_spendable(), 50_000 - details.fee.unwrap_or(0) - 5_000, "incorrect balance from fees");
                 assert_eq!(wallet.get_balance().unwrap().get_spendable(), details.received, "incorrect balance from received");
@@ -933,7 +1016,10 @@ macro_rules! bdk_blockchain_tests {
                 let (mut new_psbt, new_details) = builder.finish().expect("fee bump tx");
                 let finalized = wallet.sign(&mut new_psbt, Default::default()).unwrap();
                 assert!(finalized, "Cannot finalize transaction");
-                blockchain.broadcast(&new_psbt.extract_tx()).unwrap();
+                let tx2 = &new_psbt.extract_tx();
+                blockchain.broadcast(&tx2).unwrap();
+                #[cfg(feature = "test-cbf")]
+                test_client.wait_for_tx_in_mempool(&tx2.txid());
                 wallet.sync(&blockchain, SyncOptions::default()).unwrap();
                 assert_eq!(wallet.get_balance().unwrap().get_spendable(), 50_000 - new_details.fee.unwrap_or(0) - 5_000, "incorrect balance from fees after bump");
                 assert_eq!(wallet.get_balance().unwrap().get_spendable(), new_details.received, "incorrect balance from received after bump");
@@ -1050,9 +1136,15 @@ macro_rules! bdk_blockchain_tests {
             fn test_add_data() {
                 let (wallet, blockchain, descriptors, mut test_client) = init_single_sig();
                                 let node_addr = test_client.get_node_address(None);
-                let _ = test_client.receive(testutils! {
+                let tx = test_client.receive(testutils! {
                     @tx ( (@external descriptors, 0) => 50_000 )
                 });
+                #[cfg(feature = "test-cbf")]
+                {
+                    blockchain.broadcast(&tx).unwrap();
+                    test_client.wait_for_tx_in_mempool(&tx.txid());
+                }
+
 
                 wallet.sync(&blockchain, SyncOptions::default()).unwrap();
                 assert_eq!(wallet.get_balance().unwrap().untrusted_pending, 50_000, "incorrect balance");
@@ -1068,6 +1160,8 @@ macro_rules! bdk_blockchain_tests {
                 let serialized_tx = bitcoin::consensus::encode::serialize(&tx);
                 assert!(serialized_tx.windows(data.len()).any(|e| e==data), "cannot find op_return data in transaction");
                 blockchain.broadcast(&tx).unwrap();
+                #[cfg(feature = "test-cbf")]
+                test_client.wait_for_tx_in_mempool(&tx.txid());
                 test_client.generate(1, Some(node_addr));
                 wallet.sync(&blockchain, SyncOptions::default()).unwrap();
                 assert_eq!(wallet.get_balance().unwrap().get_spendable(), 50_000 - details.fee.unwrap_or(0), "incorrect balance after send");
@@ -1076,6 +1170,8 @@ macro_rules! bdk_blockchain_tests {
                 let _ = tx_map.get(&tx.txid()).unwrap();
             }
 
+            // This test errors in nakamoto.
+            #[cfg(not(feature = "test-cbf"))]
             #[test]
             fn test_sync_receive_coinbase() {
                 let (wallet, blockchain, _, mut test_client) = init_single_sig();
@@ -1170,10 +1266,13 @@ macro_rules! bdk_blockchain_tests {
 
                 // 3. Send 50_000 sats from test bitcoind node to test BDK wallet
 
-                test_client.receive(testutils! {
+                let tx = test_client.receive(testutils! {
                     @tx ( (@external descriptors, 0) => 50_000 )
                 });
 
+                #[cfg(feature = "test-cbf")]
+                blockchain.broadcast(&tx).unwrap();
+
                 wallet.sync(&blockchain, SyncOptions::default()).unwrap();
                 assert_eq!(wallet.get_balance().unwrap().untrusted_pending, 50_000, "wallet has incorrect balance");
 
@@ -1186,6 +1285,10 @@ macro_rules! bdk_blockchain_tests {
                 assert!(finalized, "wallet cannot finalize transaction");
                 let tx = psbt.extract_tx();
                 blockchain.broadcast(&tx).unwrap();
+
+                #[cfg(feature = "test-cbf")]
+                test_client.wait_for_tx_in_mempool(&tx.txid());
+
                 wallet.sync(&blockchain, SyncOptions::default()).unwrap();
                 assert_eq!(wallet.get_balance().unwrap().get_spendable(), details.received, "wallet has incorrect balance after send");
                 assert_eq!(wallet.list_transactions(false).unwrap().len(), 2, "wallet has incorrect number of txs");
@@ -1221,7 +1324,12 @@ macro_rules! bdk_blockchain_tests {
                 };
 
                 // Tx one: from Core #1 to Core #2 and Us #3.
-                let txid_1 = test_client.receive(tx);
+                let tx = test_client.receive(tx);
+                let txid_1 = tx.txid();
+
+                #[cfg(feature = "test-cbf")]
+                let _ = blockchain.broadcast(&tx).unwrap();
+
                 let tx_1: Transaction = deserialize(&test_client.get_transaction(&txid_1, None).unwrap().hex).unwrap();
                 let vout_1 = tx_1.output.into_iter().position(|o| o.script_pubkey == core_address.script_pubkey()).unwrap() as u32;
                 wallet.sync(&blockchain, SyncOptions::default()).unwrap();
@@ -1233,7 +1341,11 @@ macro_rules! bdk_blockchain_tests {
                 let tx = testutils! {
                     @tx ( (@addr bdk_address) => 10_000 ) ( @inputs (txid_1,vout_1))
                 };
-                let txid_2 = test_client.receive(tx);
+                let tx = test_client.receive(tx);
+                let txid_2 = tx.txid();
+
+                #[cfg(feature = "test-cbf")]
+                let _ = blockchain.broadcast(&tx).unwrap();
 
                 wallet.sync(&blockchain, SyncOptions::default()).unwrap();
                 let tx_2 = wallet.list_transactions(false).unwrap().into_iter().find(|tx| tx.txid == txid_2).unwrap();
@@ -1247,9 +1359,11 @@ macro_rules! bdk_blockchain_tests {
                 // us to do so, as it never forgets about spent UTXOs
                 let (wallet, blockchain, descriptors, mut test_client) = init_single_sig();
                 let node_addr = test_client.get_node_address(None);
-                let _ = test_client.receive(testutils! {
+                let tx = test_client.receive(testutils! {
                     @tx ( (@external descriptors, 0) => 50_000 )
                 });
+                #[cfg(feature = "test-cbf")]
+                let _ = blockchain.broadcast(&tx).unwrap();
 
                 wallet.sync(&blockchain, SyncOptions::default()).unwrap();
                 let mut builder = wallet.build_tx();
@@ -1259,6 +1373,10 @@ macro_rules! bdk_blockchain_tests {
                 assert!(finalized, "Cannot finalize transaction");
                 let initial_tx = psbt.extract_tx();
                 let _sent_txid = blockchain.broadcast(&initial_tx).unwrap();
+
+                #[cfg(feature = "test-cbf")]
+                test_client.wait_for_tx_in_mempool(&initial_tx.txid());
+
                 wallet.sync(&blockchain, SyncOptions::default()).unwrap();
                 for utxo in wallet.list_unspent().unwrap() {
                     // Making sure the TXO we just spent is not returned by list_unspent
@@ -1292,9 +1410,11 @@ macro_rules! bdk_blockchain_tests {
                 #[cfg(any(feature = "test-rpc", feature = "test-rpc-legacy"))]
                 wallet.sync(&blockchain, SyncOptions::default()).unwrap();
 
-                let _ = test_client.receive(testutils! {
+                let tx = test_client.receive(testutils! {
                     @tx ( (@external descriptors, 0) => 50_000 )
                 });
+                #[cfg(feature = "test-cbf")]
+                let _ = blockchain.broadcast(&tx).unwrap();
 
                 wallet.sync(&blockchain, SyncOptions::default()).unwrap();
 
@@ -1309,6 +1429,9 @@ macro_rules! bdk_blockchain_tests {
                 };
                 blockchain.broadcast(&tx).unwrap();
 
+                #[cfg(feature = "test-cbf")]
+                test_client.wait_for_tx_in_mempool(&tx.txid());
+
                 wallet.sync(&blockchain, SyncOptions::default()).unwrap();
             }
 
@@ -1317,9 +1440,11 @@ macro_rules! bdk_blockchain_tests {
             fn test_taproot_key_spend() {
                 let (wallet, blockchain, descriptors, mut test_client) = init_wallet(WalletType::TaprootKeySpend);
 
-                let _ = test_client.receive(testutils! {
+                let tx = test_client.receive(testutils! {
                     @tx ( (@external descriptors, 0) => 50_000 )
                 });
+                #[cfg(feature = "test-cbf")]
+                let _ = blockchain.broadcast(&tx).unwrap();
                 wallet.sync(&blockchain, SyncOptions::default()).unwrap();
                 assert_eq!(wallet.get_balance().unwrap().untrusted_pending, 50_000);
 
@@ -1442,6 +1567,8 @@ macro_rules! bdk_blockchain_tests {
                 assert_eq!(finalized, true);
             }
 
+            // TODO: Fix nanakmoto::get_block_hash().
+            #[cfg(not(feature = "test-cbf"))]
             #[test]
             fn test_get_block_hash() {
                 use bitcoincore_rpc::{ RpcApi };

From 7e12db59821a92e8b7ad649848edba88b49d6e36 Mon Sep 17 00:00:00 2001
From: rajarshimaitra <rajarshi149@gmail.com>
Date: Wed, 12 Oct 2022 12:27:02 +0530
Subject: [PATCH 3/6] Add nakamoto into extra infra

Include CbfNode in AnyBlockchain enum
Impl ConfigurableBlockchain for CbfNode
---
 src/blockchain/any.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/blockchain/any.rs b/src/blockchain/any.rs
index 38b5f117f..082f9e38a 100644
--- a/src/blockchain/any.rs
+++ b/src/blockchain/any.rs
@@ -84,7 +84,7 @@ pub enum AnyBlockchain {
     #[cfg(feature = "compact_filters")]
     #[cfg_attr(docsrs, doc(cfg(feature = "compact_filters")))]
     /// Compact filters client
-    CompactFilters(Box<compact_filters::CompactFiltersBlockchain>),
+    CompactFilters(Box<compact_filters::nakamoto::CbfBlockchain>),
     #[cfg(feature = "rpc")]
     #[cfg_attr(docsrs, doc(cfg(feature = "rpc")))]
     /// RPC client
@@ -158,7 +158,7 @@ impl WalletSync for AnyBlockchain {
 
 impl_from!(boxed electrum::ElectrumBlockchain, AnyBlockchain, Electrum, #[cfg(feature = "electrum")]);
 impl_from!(boxed esplora::EsploraBlockchain, AnyBlockchain, Esplora, #[cfg(feature = "esplora")]);
-impl_from!(boxed compact_filters::CompactFiltersBlockchain, AnyBlockchain, CompactFilters, #[cfg(feature = "compact_filters")]);
+impl_from!(boxed compact_filters::nakamoto::CbfBlockchain, AnyBlockchain, CompactFilters, #[cfg(feature = "compact_filters")]);
 impl_from!(boxed rpc::RpcBlockchain, AnyBlockchain, Rpc, #[cfg(feature = "rpc")]);
 
 /// Type that can contain any of the blockchain configurations defined by the library
@@ -210,7 +210,7 @@ pub enum AnyBlockchainConfig {
     #[cfg(feature = "compact_filters")]
     #[cfg_attr(docsrs, doc(cfg(feature = "compact_filters")))]
     /// Compact filters client
-    CompactFilters(compact_filters::CompactFiltersBlockchainConfig),
+    CompactFilters(compact_filters::nakamoto::CBFBlockchainConfig),
     #[cfg(feature = "rpc")]
     #[cfg_attr(docsrs, doc(cfg(feature = "rpc")))]
     /// RPC client configuration
@@ -232,7 +232,7 @@ impl ConfigurableBlockchain for AnyBlockchain {
             }
             #[cfg(feature = "compact_filters")]
             AnyBlockchainConfig::CompactFilters(inner) => AnyBlockchain::CompactFilters(Box::new(
-                compact_filters::CompactFiltersBlockchain::from_config(inner)?,
+                compact_filters::nakamoto::CbfBlockchain::from_config(inner)?,
             )),
             #[cfg(feature = "rpc")]
             AnyBlockchainConfig::Rpc(inner) => {
@@ -244,5 +244,5 @@ impl ConfigurableBlockchain for AnyBlockchain {
 
 impl_from!(electrum::ElectrumBlockchainConfig, AnyBlockchainConfig, Electrum, #[cfg(feature = "electrum")]);
 impl_from!(esplora::EsploraBlockchainConfig, AnyBlockchainConfig, Esplora, #[cfg(feature = "esplora")]);
-impl_from!(compact_filters::CompactFiltersBlockchainConfig, AnyBlockchainConfig, CompactFilters, #[cfg(feature = "compact_filters")]);
+impl_from!(compact_filters::nakamoto::CBFBlockchainConfig, AnyBlockchainConfig, CompactFilters, #[cfg(feature = "compact_filters")]);
 impl_from!(rpc::RpcConfig, AnyBlockchainConfig, Rpc, #[cfg(feature = "rpc")]);

From 58c12e230237e7e65c33bc27ef828fea6ed0be9c Mon Sep 17 00:00:00 2001
From: rajarshimaitra <rajarshi149@gmail.com>
Date: Thu, 13 Oct 2022 10:17:44 +0530
Subject: [PATCH 4/6] Disable existing Compact Filters module

This commit comments out existing compact filters module so only
nakamoto dependencies get compiled with compact_filters features.
---
 Cargo.toml                              |    2 +-
 examples/compact_filters_balance.rs     |   77 +-
 src/blockchain/compact_filters/mod.rs   | 1240 ++++++++---------
 src/blockchain/compact_filters/peer.rs  | 1152 ++++++++--------
 src/blockchain/compact_filters/store.rs | 1672 +++++++++++------------
 src/blockchain/compact_filters/sync.rs  |  594 ++++----
 src/blockchain/mod.rs                   |    2 +-
 src/error.rs                            |   24 +-
 8 files changed, 2384 insertions(+), 2379 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 139d7a66c..18be260b4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -59,7 +59,7 @@ verify = ["bitcoinconsensus"]
 default = ["key-value-db", "electrum"]
 sqlite = ["rusqlite", "ahash"]
 sqlite-bundled = ["sqlite", "rusqlite/bundled"]
-compact_filters = ["rocksdb", "socks", "cc", "nakamoto"]
+compact_filters = ["nakamoto"]
 key-value-db = ["sled"]
 all-keys = ["keys-bip39"]
 keys-bip39 = ["bip39"]
diff --git a/examples/compact_filters_balance.rs b/examples/compact_filters_balance.rs
index ce875b4d5..1c148bf47 100644
--- a/examples/compact_filters_balance.rs
+++ b/examples/compact_filters_balance.rs
@@ -1,41 +1,46 @@
-// Bitcoin Dev Kit
-// Written in 2020 by Alekos Filini <alekos.filini@gmail.com>
-//
-// Copyright (c) 2020-2021 Bitcoin Dev Kit Developers
-//
-// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
-// or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
-// You may not use this file except in accordance with one or both of these
-// licenses.
+// // Bitcoin Dev Kit
+// // Written in 2020 by Alekos Filini <alekos.filini@gmail.com>
+// //
+// // Copyright (c) 2020-2021 Bitcoin Dev Kit Developers
+// //
+// // This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
+// // or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
+// // You may not use this file except in accordance with one or both of these
+// // licenses.
 
-use bdk::blockchain::compact_filters::*;
-use bdk::database::MemoryDatabase;
-use bdk::*;
-use bitcoin::*;
-use blockchain::compact_filters::CompactFiltersBlockchain;
-use blockchain::compact_filters::CompactFiltersError;
-use log::info;
-use std::sync::Arc;
+// use bdk::blockchain::compact_filters::*;
+// use bdk::database::MemoryDatabase;
+// use bdk::*;
+// use bitcoin::*;
+// use blockchain::compact_filters::CompactFiltersBlockchain;
+// use blockchain::compact_filters::CompactFiltersError;
+// use log::info;
+// use std::sync::Arc;
 
-/// This will return wallet balance using compact filters
-/// Requires a synced local bitcoin node 0.21 running on testnet with blockfilterindex=1 and peerblockfilters=1
-fn main() -> Result<(), CompactFiltersError> {
-    env_logger::init();
-    info!("start");
+// /// This will return wallet balance using compact filters
+// /// Requires a synced local bitcoin node 0.21 running on testnet with blockfilterindex=1 and peerblockfilters=1
+// fn main() -> Result<(), CompactFiltersError> {
+//     env_logger::init();
+//     info!("start");
 
-    let num_threads = 4;
-    let mempool = Arc::new(Mempool::default());
-    let peers = (0..num_threads)
-        .map(|_| Peer::connect("localhost:18333", Arc::clone(&mempool), Network::Testnet))
-        .collect::<Result<_, _>>()?;
-    let blockchain = CompactFiltersBlockchain::new(peers, "./wallet-filters", Some(500_000))?;
-    info!("done {:?}", blockchain);
-    let descriptor = "wpkh(tpubD6NzVbkrYhZ4X2yy78HWrr1M9NT8dKeWfzNiQqDdMqqa9UmmGztGGz6TaLFGsLfdft5iu32gxq1T4eMNxExNNWzVCpf9Y6JZi5TnqoC9wJq/*)";
+//     let num_threads = 4;
+//     let mempool = Arc::new(Mempool::default());
+//     let peers = (0..num_threads)
+//         .map(|_| Peer::connect("localhost:18333", Arc::clone(&mempool), Network::Testnet))
+//         .collect::<Result<_, _>>()?;
+//     let blockchain = CompactFiltersBlockchain::new(peers, "./wallet-filters", Some(500_000))?;
+//     info!("done {:?}", blockchain);
+//     let descriptor = "wpkh(tpubD6NzVbkrYhZ4X2yy78HWrr1M9NT8dKeWfzNiQqDdMqqa9UmmGztGGz6TaLFGsLfdft5iu32gxq1T4eMNxExNNWzVCpf9Y6JZi5TnqoC9wJq/*)";
+
+//     let database = MemoryDatabase::default();
+//     let wallet = Arc::new(Wallet::new(descriptor, None, Network::Testnet, database).unwrap());
+//     wallet.sync(&blockchain, SyncOptions::default()).unwrap();
+//     info!("balance: {}", wallet.get_balance()?);
+//     Ok(())
+// }
+
+// TODO make a nakamoto example
+fn main() {
 
-    let database = MemoryDatabase::default();
-    let wallet = Arc::new(Wallet::new(descriptor, None, Network::Testnet, database).unwrap());
-    wallet.sync(&blockchain, SyncOptions::default()).unwrap();
-    info!("balance: {}", wallet.get_balance()?);
-    Ok(())
 }
diff --git a/src/blockchain/compact_filters/mod.rs b/src/blockchain/compact_filters/mod.rs
index d88d59620..2caeccea3 100644
--- a/src/blockchain/compact_filters/mod.rs
+++ b/src/blockchain/compact_filters/mod.rs
@@ -1,620 +1,620 @@
-// Bitcoin Dev Kit
-// Written in 2020 by Alekos Filini <alekos.filini@gmail.com>
-//
-// Copyright (c) 2020-2021 Bitcoin Dev Kit Developers
-//
-// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
-// or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
-// You may not use this file except in accordance with one or both of these
-// licenses.
-
-//! Compact Filters
-//!
-//! This module contains a multithreaded implementation of an [`Blockchain`] backend that
-//! uses BIP157 (aka "Neutrino") to populate the wallet's [database](crate::database::Database)
-//! by downloading compact filters from the P2P network.
-//!
-//! Since there are currently very few peers "in the wild" that advertise the required service
-//! flag, this implementation requires that one or more known peers are provided by the user.
-//! No dns or other kinds of peer discovery are done internally.
-//!
-//! Moreover, this module doesn't currently support detecting and resolving conflicts between
-//! messages received by different peers. Thus, it's recommended to use this module by only
-//! connecting to a single peer at a time, optionally by opening multiple connections if it's
-//! desirable to use multiple threads at once to sync in parallel.
-//!
-//! This is an **EXPERIMENTAL** feature, API and other major changes are expected.
-//!
-//! ## Example
-//!
-//! ```no_run
-//! # use std::sync::Arc;
-//! # use bitcoin::*;
-//! # use bdk::*;
-//! # use bdk::blockchain::compact_filters::*;
-//! let num_threads = 4;
-//!
-//! let mempool = Arc::new(Mempool::default());
-//! let peers = (0..num_threads)
-//!     .map(|_| {
-//!         Peer::connect(
-//!             "btcd-mainnet.lightning.computer:8333",
-//!             Arc::clone(&mempool),
-//!             Network::Bitcoin,
-//!         )
-//!     })
-//!     .collect::<Result<_, _>>()?;
-//! let blockchain = CompactFiltersBlockchain::new(peers, "./wallet-filters", Some(500_000))?;
-//! # Ok::<(), CompactFiltersError>(())
-//! ```
-
-use std::collections::HashSet;
-use std::fmt;
-use std::ops::DerefMut;
-use std::path::Path;
-use std::sync::atomic::{AtomicUsize, Ordering};
-use std::sync::{Arc, Mutex};
-
-#[allow(unused_imports)]
-use log::{debug, error, info, trace};
-
-use bitcoin::network::message_blockdata::Inventory;
-use bitcoin::{Network, OutPoint, Transaction, Txid};
-
-use rocksdb::{Options, SliceTransform, DB};
-
-mod peer;
-mod store;
-mod sync;
-
-pub mod nakamoto;
-
-use crate::blockchain::*;
-use crate::database::{BatchDatabase, BatchOperations, DatabaseUtils};
-use crate::error::Error;
-use crate::types::{KeychainKind, LocalUtxo, TransactionDetails};
-use crate::{BlockTime, FeeRate};
-
-use peer::*;
-use store::*;
-use sync::*;
-
-pub use peer::{Mempool, Peer};
-
-const SYNC_HEADERS_COST: f32 = 1.0;
-const SYNC_FILTERS_COST: f32 = 11.6 * 1_000.0;
-const PROCESS_BLOCKS_COST: f32 = 20_000.0;
-
-/// Structure implementing the required blockchain traits
-///
-/// ## Example
-/// See the [`blockchain::compact_filters`](crate::blockchain::compact_filters) module for a usage example.
-#[derive(Debug)]
-pub struct CompactFiltersBlockchain {
-    peers: Vec<Arc<Peer>>,
-    headers: Arc<ChainStore<Full>>,
-    skip_blocks: Option<usize>,
-}
-
-impl CompactFiltersBlockchain {
-    /// Construct a new instance given a list of peers, a path to store headers and block
-    /// filters downloaded during the sync and optionally a number of blocks to ignore starting
-    /// from the genesis while scanning for the wallet's outputs.
-    ///
-    /// For each [`Peer`] specified a new thread will be spawned to download and verify the filters
-    /// in parallel. It's currently recommended to only connect to a single peer to avoid
-    /// inconsistencies in the data returned, optionally with multiple connections in parallel to
-    /// speed-up the sync process.
-    pub fn new<P: AsRef<Path>>(
-        peers: Vec<Peer>,
-        storage_dir: P,
-        skip_blocks: Option<usize>,
-    ) -> Result<Self, CompactFiltersError> {
-        if peers.is_empty() {
-            return Err(CompactFiltersError::NoPeers);
-        }
-
-        let mut opts = Options::default();
-        opts.create_if_missing(true);
-        opts.set_prefix_extractor(SliceTransform::create_fixed_prefix(16));
-
-        let network = peers[0].get_network();
-
-        let cfs = DB::list_cf(&opts, &storage_dir).unwrap_or_else(|_| vec!["default".to_string()]);
-        let db = DB::open_cf(&opts, &storage_dir, &cfs)?;
-        let headers = Arc::new(ChainStore::new(db, network)?);
-
-        // try to recover partial snapshots
-        for cf_name in &cfs {
-            if !cf_name.starts_with("_headers:") {
-                continue;
-            }
-
-            info!("Trying to recover: {:?}", cf_name);
-            headers.recover_snapshot(cf_name)?;
-        }
-
-        Ok(CompactFiltersBlockchain {
-            peers: peers.into_iter().map(Arc::new).collect(),
-            headers,
-            skip_blocks,
-        })
-    }
-
-    /// Process a transaction by looking for inputs that spend from a UTXO in the database or
-    /// outputs that send funds to a know script_pubkey.
-    fn process_tx<D: BatchDatabase>(
-        &self,
-        database: &mut D,
-        tx: &Transaction,
-        height: Option<u32>,
-        timestamp: Option<u64>,
-        internal_max_deriv: &mut Option<u32>,
-        external_max_deriv: &mut Option<u32>,
-    ) -> Result<(), Error> {
-        let mut updates = database.begin_batch();
-
-        let mut incoming: u64 = 0;
-        let mut outgoing: u64 = 0;
-
-        let mut inputs_sum: u64 = 0;
-        let mut outputs_sum: u64 = 0;
-
-        // look for our own inputs
-        for (i, input) in tx.input.iter().enumerate() {
-            if let Some(previous_output) = database.get_previous_output(&input.previous_output)? {
-                inputs_sum += previous_output.value;
-
-                // this output is ours, we have a path to derive it
-                if let Some((keychain, _)) =
-                    database.get_path_from_script_pubkey(&previous_output.script_pubkey)?
-                {
-                    outgoing += previous_output.value;
-
-                    debug!("{} input #{} is mine, setting utxo as spent", tx.txid(), i);
-                    updates.set_utxo(&LocalUtxo {
-                        outpoint: input.previous_output,
-                        txout: previous_output.clone(),
-                        keychain,
-                        is_spent: true,
-                    })?;
-                }
-            }
-        }
-
-        for (i, output) in tx.output.iter().enumerate() {
-            // to compute the fees later
-            outputs_sum += output.value;
-
-            // this output is ours, we have a path to derive it
-            if let Some((keychain, child)) =
-                database.get_path_from_script_pubkey(&output.script_pubkey)?
-            {
-                debug!("{} output #{} is mine, adding utxo", tx.txid(), i);
-                updates.set_utxo(&LocalUtxo {
-                    outpoint: OutPoint::new(tx.txid(), i as u32),
-                    txout: output.clone(),
-                    keychain,
-                    is_spent: false,
-                })?;
-                incoming += output.value;
-
-                if keychain == KeychainKind::Internal
-                    && (internal_max_deriv.is_none() || child > internal_max_deriv.unwrap_or(0))
-                {
-                    *internal_max_deriv = Some(child);
-                } else if keychain == KeychainKind::External
-                    && (external_max_deriv.is_none() || child > external_max_deriv.unwrap_or(0))
-                {
-                    *external_max_deriv = Some(child);
-                }
-            }
-        }
-
-        if incoming > 0 || outgoing > 0 {
-            let tx = TransactionDetails {
-                txid: tx.txid(),
-                transaction: Some(tx.clone()),
-                received: incoming,
-                sent: outgoing,
-                confirmation_time: BlockTime::new(height, timestamp),
-                fee: Some(inputs_sum.saturating_sub(outputs_sum)),
-            };
-
-            info!("Saving tx {}", tx.txid);
-            updates.set_tx(&tx)?;
-        }
-
-        database.commit_batch(updates)?;
-
-        Ok(())
-    }
-}
-
-impl Blockchain for CompactFiltersBlockchain {
-    fn get_capabilities(&self) -> HashSet<Capability> {
-        vec![Capability::FullHistory].into_iter().collect()
-    }
-
-    fn broadcast(&self, tx: &Transaction) -> Result<(), Error> {
-        self.peers[0].broadcast_tx(tx.clone())?;
-
-        Ok(())
-    }
-
-    fn estimate_fee(&self, _target: usize) -> Result<FeeRate, Error> {
-        // TODO
-        Ok(FeeRate::default())
-    }
-}
-
-impl GetHeight for CompactFiltersBlockchain {
-    fn get_height(&self) -> Result<u32, Error> {
-        Ok(self.headers.get_height()? as u32)
-    }
-}
-
-impl GetTx for CompactFiltersBlockchain {
-    fn get_tx(&self, txid: &Txid) -> Result<Option<Transaction>, Error> {
-        Ok(self.peers[0]
-            .get_mempool()
-            .get_tx(&Inventory::Transaction(*txid)))
-    }
-}
-
-impl GetBlockHash for CompactFiltersBlockchain {
-    fn get_block_hash(&self, height: u64) -> Result<BlockHash, Error> {
-        self.headers
-            .get_block_hash(height as usize)?
-            .ok_or(Error::CompactFilters(
-                CompactFiltersError::BlockHashNotFound,
-            ))
-    }
-}
-
-impl WalletSync for CompactFiltersBlockchain {
-    #[allow(clippy::mutex_atomic)] // Mutex is easier to understand than a CAS loop.
-    fn wallet_setup<D: BatchDatabase>(
-        &self,
-        database: &RefCell<D>,
-        progress_update: Box<dyn Progress>,
-    ) -> Result<(), Error> {
-        let first_peer = &self.peers[0];
-
-        let skip_blocks = self.skip_blocks.unwrap_or(0);
-
-        let cf_sync = Arc::new(CfSync::new(Arc::clone(&self.headers), skip_blocks, 0x00)?);
-
-        let initial_height = self.headers.get_height()?;
-        let total_bundles = (first_peer.get_version().start_height as usize)
-            .checked_sub(skip_blocks)
-            .map(|x| x / 1000)
-            .unwrap_or(0)
-            + 1;
-        let expected_bundles_to_sync = total_bundles.saturating_sub(cf_sync.pruned_bundles()?);
-
-        let headers_cost = (first_peer.get_version().start_height as usize)
-            .saturating_sub(initial_height) as f32
-            * SYNC_HEADERS_COST;
-        let filters_cost = expected_bundles_to_sync as f32 * SYNC_FILTERS_COST;
-
-        let total_cost = headers_cost + filters_cost + PROCESS_BLOCKS_COST;
-
-        if let Some(snapshot) = sync::sync_headers(
-            Arc::clone(first_peer),
-            Arc::clone(&self.headers),
-            |new_height| {
-                let local_headers_cost =
-                    new_height.saturating_sub(initial_height) as f32 * SYNC_HEADERS_COST;
-                progress_update.update(
-                    local_headers_cost / total_cost * 100.0,
-                    Some(format!("Synced headers to {}", new_height)),
-                )
-            },
-        )? {
-            if snapshot.work()? > self.headers.work()? {
-                info!("Applying snapshot with work: {}", snapshot.work()?);
-                self.headers.apply_snapshot(snapshot)?;
-            }
-        }
-
-        let synced_height = self.headers.get_height()?;
-        let buried_height = synced_height.saturating_sub(sync::BURIED_CONFIRMATIONS);
-        info!("Synced headers to height: {}", synced_height);
-
-        cf_sync.prepare_sync(Arc::clone(first_peer))?;
-
-        let mut database = database.borrow_mut();
-        let database = database.deref_mut();
-
-        let all_scripts = Arc::new(
-            database
-                .iter_script_pubkeys(None)?
-                .into_iter()
-                .map(|s| s.to_bytes())
-                .collect::<Vec<_>>(),
-        );
-
-        #[allow(clippy::mutex_atomic)]
-        let last_synced_block = Arc::new(Mutex::new(synced_height));
-
-        let synced_bundles = Arc::new(AtomicUsize::new(0));
-        let progress_update = Arc::new(Mutex::new(progress_update));
-
-        let mut threads = Vec::with_capacity(self.peers.len());
-        for peer in &self.peers {
-            let cf_sync = Arc::clone(&cf_sync);
-            let peer = Arc::clone(peer);
-            let headers = Arc::clone(&self.headers);
-            let all_scripts = Arc::clone(&all_scripts);
-            let last_synced_block = Arc::clone(&last_synced_block);
-            let progress_update = Arc::clone(&progress_update);
-            let synced_bundles = Arc::clone(&synced_bundles);
-
-            let thread = std::thread::spawn(move || {
-                cf_sync.capture_thread_for_sync(
-                    peer,
-                    |block_hash, filter| {
-                        if !filter
-                            .match_any(block_hash, &mut all_scripts.iter().map(AsRef::as_ref))?
-                        {
-                            return Ok(false);
-                        }
-
-                        let block_height = headers.get_height_for(block_hash)?.unwrap_or(0);
-                        let saved_correct_block = matches!(headers.get_full_block(block_height)?, Some(block) if &block.block_hash() == block_hash);
-
-                        if saved_correct_block {
-                            Ok(false)
-                        } else {
-                            let mut last_synced_block = last_synced_block.lock().unwrap();
-
-                            // If we download a block older than `last_synced_block`, we update it so that
-                            // we know to delete and re-process all txs starting from that height
-                            if block_height < *last_synced_block {
-                                *last_synced_block = block_height;
-                            }
-
-                            Ok(true)
-                        }
-                    },
-                    |index| {
-                        let synced_bundles = synced_bundles.fetch_add(1, Ordering::SeqCst);
-                        let local_filters_cost = synced_bundles as f32 * SYNC_FILTERS_COST;
-                        progress_update.lock().unwrap().update(
-                            (headers_cost + local_filters_cost) / total_cost * 100.0,
-                            Some(format!(
-                                "Synced filters {} - {}",
-                                index * 1000 + 1,
-                                (index + 1) * 1000
-                            )),
-                        )
-                    },
-                )
-            });
-
-            threads.push(thread);
-        }
-
-        for t in threads {
-            t.join().unwrap()?;
-        }
-
-        progress_update.lock().unwrap().update(
-            (headers_cost + filters_cost) / total_cost * 100.0,
-            Some("Processing downloaded blocks and mempool".into()),
-        )?;
-
-        // delete all txs newer than last_synced_block
-        let last_synced_block = *last_synced_block.lock().unwrap();
-        log::debug!(
-            "Dropping transactions newer than `last_synced_block` = {}",
-            last_synced_block
-        );
-        let mut updates = database.begin_batch();
-        for details in database.iter_txs(false)? {
-            match details.confirmation_time {
-                Some(c) if (c.height as usize) < last_synced_block => continue,
-                _ => updates.del_tx(&details.txid, false)?,
-            };
-        }
-        database.commit_batch(updates)?;
-
-        match first_peer.ask_for_mempool() {
-            Err(CompactFiltersError::PeerBloomDisabled) => {
-                log::warn!("Peer has BLOOM disabled, we can't ask for the mempool")
-            }
-            e => e?,
-        };
-
-        let mut internal_max_deriv = None;
-        let mut external_max_deriv = None;
-
-        for (height, block) in self.headers.iter_full_blocks()? {
-            for tx in &block.txdata {
-                self.process_tx(
-                    database,
-                    tx,
-                    Some(height as u32),
-                    None,
-                    &mut internal_max_deriv,
-                    &mut external_max_deriv,
-                )?;
-            }
-        }
-        for tx in first_peer.get_mempool().iter_txs().iter() {
-            self.process_tx(
-                database,
-                tx,
-                None,
-                None,
-                &mut internal_max_deriv,
-                &mut external_max_deriv,
-            )?;
-        }
-
-        let current_ext = database
-            .get_last_index(KeychainKind::External)?
-            .unwrap_or(0);
-        let first_ext_new = external_max_deriv.map(|x| x + 1).unwrap_or(0);
-        if first_ext_new > current_ext {
-            info!("Setting external index to {}", first_ext_new);
-            database.set_last_index(KeychainKind::External, first_ext_new)?;
-        }
-
-        let current_int = database
-            .get_last_index(KeychainKind::Internal)?
-            .unwrap_or(0);
-        let first_int_new = internal_max_deriv.map(|x| x + 1).unwrap_or(0);
-        if first_int_new > current_int {
-            info!("Setting internal index to {}", first_int_new);
-            database.set_last_index(KeychainKind::Internal, first_int_new)?;
-        }
-
-        info!("Dropping blocks until {}", buried_height);
-        self.headers.delete_blocks_until(buried_height)?;
-
-        progress_update
-            .lock()
-            .unwrap()
-            .update(100.0, Some("Done".into()))?;
-
-        Ok(())
-    }
-}
-
-/// Data to connect to a Bitcoin P2P peer
-#[derive(Debug, serde::Deserialize, serde::Serialize, Clone, PartialEq, Eq)]
-pub struct BitcoinPeerConfig {
-    /// Peer address such as 127.0.0.1:18333
-    pub address: String,
-    /// Optional socks5 proxy
-    pub socks5: Option<String>,
-    /// Optional socks5 proxy credentials
-    pub socks5_credentials: Option<(String, String)>,
-}
-
-/// Configuration for a [`CompactFiltersBlockchain`]
-#[derive(Debug, serde::Deserialize, serde::Serialize, Clone, PartialEq, Eq)]
-pub struct CompactFiltersBlockchainConfig {
-    /// List of peers to try to connect to for asking headers and filters
-    pub peers: Vec<BitcoinPeerConfig>,
-    /// Network used
-    pub network: Network,
-    /// Storage dir to save partially downloaded headers and full blocks. Should be a separate directory per descriptor. Consider using [crate::wallet::wallet_name_from_descriptor] for this.
-    pub storage_dir: String,
-    /// Optionally skip initial `skip_blocks` blocks (default: 0)
-    pub skip_blocks: Option<usize>,
-}
-
-impl ConfigurableBlockchain for CompactFiltersBlockchain {
-    type Config = CompactFiltersBlockchainConfig;
-
-    fn from_config(config: &Self::Config) -> Result<Self, Error> {
-        let mempool = Arc::new(Mempool::default());
-        let peers = config
-            .peers
-            .iter()
-            .map(|peer_conf| match &peer_conf.socks5 {
-                None => Peer::connect(&peer_conf.address, Arc::clone(&mempool), config.network),
-                Some(proxy) => Peer::connect_proxy(
-                    peer_conf.address.as_str(),
-                    proxy,
-                    peer_conf
-                        .socks5_credentials
-                        .as_ref()
-                        .map(|(a, b)| (a.as_str(), b.as_str())),
-                    Arc::clone(&mempool),
-                    config.network,
-                ),
-            })
-            .collect::<Result<_, _>>()?;
-
-        Ok(CompactFiltersBlockchain::new(
-            peers,
-            &config.storage_dir,
-            config.skip_blocks,
-        )?)
-    }
-}
-
-/// An error that can occur during sync with a [`CompactFiltersBlockchain`]
-#[derive(Debug)]
-pub enum CompactFiltersError {
-    /// A peer sent an invalid or unexpected response
-    InvalidResponse,
-    /// The headers returned are invalid
-    InvalidHeaders,
-    /// The compact filter headers returned are invalid
-    InvalidFilterHeader,
-    /// The compact filter returned is invalid
-    InvalidFilter,
-    /// The peer is missing a block in the valid chain
-    MissingBlock,
-    /// Block hash at specified height not found
-    BlockHashNotFound,
-    /// The data stored in the block filters storage are corrupted
-    DataCorruption,
-
-    /// A peer is not connected
-    NotConnected,
-    /// A peer took too long to reply to one of our messages
-    Timeout,
-    /// The peer doesn't advertise the [`BLOOM`](bitcoin::network::constants::ServiceFlags::BLOOM) service flag
-    PeerBloomDisabled,
-
-    /// No peers have been specified
-    NoPeers,
-
-    /// Internal database error
-    Db(rocksdb::Error),
-    /// Internal I/O error
-    Io(std::io::Error),
-    /// Invalid BIP158 filter
-    Bip158(bitcoin::util::bip158::Error),
-    /// Internal system time error
-    Time(std::time::SystemTimeError),
-
-    /// Wrapper for [`crate::error::Error`]
-    Global(Box<crate::error::Error>),
-}
-
-impl fmt::Display for CompactFiltersError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::InvalidResponse => write!(f, "A peer sent an invalid or unexpected response"),
-            Self::InvalidHeaders => write!(f, "Invalid headers"),
-            Self::InvalidFilterHeader => write!(f, "Invalid filter header"),
-            Self::InvalidFilter => write!(f, "Invalid filters"),
-            Self::MissingBlock => write!(f, "The peer is missing a block in the valid chain"),
-            Self::BlockHashNotFound => write!(f, "Block hash not found"),
-            Self::DataCorruption => write!(
-                f,
-                "The data stored in the block filters storage are corrupted"
-            ),
-            Self::NotConnected => write!(f, "A peer is not connected"),
-            Self::Timeout => write!(f, "A peer took too long to reply to one of our messages"),
-            Self::PeerBloomDisabled => write!(f, "Peer doesn't advertise the BLOOM service flag"),
-            Self::NoPeers => write!(f, "No peers have been specified"),
-            Self::Db(err) => write!(f, "Internal database error: {}", err),
-            Self::Io(err) => write!(f, "Internal I/O error: {}", err),
-            Self::Bip158(err) => write!(f, "Invalid BIP158 filter: {}", err),
-            Self::Time(err) => write!(f, "Invalid system time: {}", err),
-            Self::Global(err) => write!(f, "Generic error: {}", err),
-        }
-    }
-}
-
-impl std::error::Error for CompactFiltersError {}
-
-impl_error!(rocksdb::Error, Db, CompactFiltersError);
-impl_error!(std::io::Error, Io, CompactFiltersError);
-impl_error!(bitcoin::util::bip158::Error, Bip158, CompactFiltersError);
-impl_error!(std::time::SystemTimeError, Time, CompactFiltersError);
-
-impl From<crate::error::Error> for CompactFiltersError {
-    fn from(err: crate::error::Error) -> Self {
-        CompactFiltersError::Global(Box::new(err))
-    }
-}
+// // // Bitcoin Dev Kit
+// // // Written in 2020 by Alekos Filini <alekos.filini@gmail.com>
+// // //
+// // // Copyright (c) 2020-2021 Bitcoin Dev Kit Developers
+// // //
+// // // This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
+// // // or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// // // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
+// // // You may not use this file except in accordance with one or both of these
+// // // licenses.
+
+// //! Compact Filters
+// //!
+// //! This module contains a multithreaded implementation of an [`Blockchain`] backend that
+// //! uses BIP157 (aka "Neutrino") to populate the wallet's [database](crate::database::Database)
+// //! by downloading compact filters from the P2P network.
+// //!
+// //! Since there are currently very few peers "in the wild" that advertise the required service
+// //! flag, this implementation requires that one or more known peers are provided by the user.
+// //! No dns or other kinds of peer discovery are done internally.
+// //!
+// //! Moreover, this module doesn't currently support detecting and resolving conflicts between
+// //! messages received by different peers. Thus, it's recommended to use this module by only
+// //! connecting to a single peer at a time, optionally by opening multiple connections if it's
+// //! desirable to use multiple threads at once to sync in parallel.
+// //!
+// //! This is an **EXPERIMENTAL** feature, API and other major changes are expected.
+// //!
+// //! ## Example
+// //!
+// //! ```no_run
+// //! # use std::sync::Arc;
+// //! # use bitcoin::*;
+// //! # use bdk::*;
+// //! # use bdk::blockchain::compact_filters::*;
+// //! let num_threads = 4;
+// //!
+// //! let mempool = Arc::new(Mempool::default());
+// //! let peers = (0..num_threads)
+// //!     .map(|_| {
+// //!         Peer::connect(
+// //!             "btcd-mainnet.lightning.computer:8333",
+// //!             Arc::clone(&mempool),
+// //!             Network::Bitcoin,
+// //!         )
+// //!     })
+// //!     .collect::<Result<_, _>>()?;
+// //! let blockchain = CompactFiltersBlockchain::new(peers, "./wallet-filters", Some(500_000))?;
+// //! # Ok::<(), CompactFiltersError>(())
+// //! ```
+
+// use std::collections::HashSet;
+// use std::fmt;
+// use std::ops::DerefMut;
+// use std::path::Path;
+// use std::sync::atomic::{AtomicUsize, Ordering};
+// use std::sync::{Arc, Mutex};
+
+// // #[allow(unused_imports)]
+// // use log::{debug, error, info, trace};
+
+// // use bitcoin::network::message_blockdata::Inventory;
+// // use bitcoin::{Network, OutPoint, Transaction, Txid};
+
+// // use rocksdb::{Options, SliceTransform, DB};
+
+// // mod peer;
+// // mod store;
+// // mod sync;
+
+// pub mod nakamoto;
+
+// use crate::blockchain::*;
+// use crate::database::{BatchDatabase, BatchOperations, DatabaseUtils};
+// use crate::error::Error;
+// use crate::types::{KeychainKind, LocalUtxo, TransactionDetails};
+// use crate::{BlockTime, FeeRate};
+
+// use peer::*;
+// use store::*;
+// use sync::*;
+
+// pub use peer::{Mempool, Peer};
+
+// const SYNC_HEADERS_COST: f32 = 1.0;
+// const SYNC_FILTERS_COST: f32 = 11.6 * 1_000.0;
+// const PROCESS_BLOCKS_COST: f32 = 20_000.0;
+
+// /// Structure implementing the required blockchain traits
+// ///
+// /// ## Example
+// /// See the [`blockchain::compact_filters`](crate::blockchain::compact_filters) module for a usage example.
+// #[derive(Debug)]
+// pub struct CompactFiltersBlockchain {
+//     peers: Vec<Arc<Peer>>,
+//     headers: Arc<ChainStore<Full>>,
+//     skip_blocks: Option<usize>,
+// }
+
+// impl CompactFiltersBlockchain {
+//     /// Construct a new instance given a list of peers, a path to store headers and block
+//     /// filters downloaded during the sync and optionally a number of blocks to ignore starting
+//     /// from the genesis while scanning for the wallet's outputs.
+//     ///
+//     /// For each [`Peer`] specified a new thread will be spawned to download and verify the filters
+//     /// in parallel. It's currently recommended to only connect to a single peer to avoid
+//     /// inconsistencies in the data returned, optionally with multiple connections in parallel to
+//     /// speed-up the sync process.
+//     pub fn new<P: AsRef<Path>>(
+//         peers: Vec<Peer>,
+//         storage_dir: P,
+//         skip_blocks: Option<usize>,
+//     ) -> Result<Self, CompactFiltersError> {
+//         if peers.is_empty() {
+//             return Err(CompactFiltersError::NoPeers);
+//         }
+
+//         let mut opts = Options::default();
+//         opts.create_if_missing(true);
+//         opts.set_prefix_extractor(SliceTransform::create_fixed_prefix(16));
+
+//         let network = peers[0].get_network();
+
+//         let cfs = DB::list_cf(&opts, &storage_dir).unwrap_or_else(|_| vec!["default".to_string()]);
+//         let db = DB::open_cf(&opts, &storage_dir, &cfs)?;
+//         let headers = Arc::new(ChainStore::new(db, network)?);
+
+//         // try to recover partial snapshots
+//         for cf_name in &cfs {
+//             if !cf_name.starts_with("_headers:") {
+//                 continue;
+//             }
+
+//             info!("Trying to recover: {:?}", cf_name);
+//             headers.recover_snapshot(cf_name)?;
+//         }
+
+//         Ok(CompactFiltersBlockchain {
+//             peers: peers.into_iter().map(Arc::new).collect(),
+//             headers,
+//             skip_blocks,
+//         })
+//     }
+
+//     /// Process a transaction by looking for inputs that spend from a UTXO in the database or
+//     /// outputs that send funds to a know script_pubkey.
+//     fn process_tx<D: BatchDatabase>(
+//         &self,
+//         database: &mut D,
+//         tx: &Transaction,
+//         height: Option<u32>,
+//         timestamp: Option<u64>,
+//         internal_max_deriv: &mut Option<u32>,
+//         external_max_deriv: &mut Option<u32>,
+//     ) -> Result<(), Error> {
+//         let mut updates = database.begin_batch();
+
+//         let mut incoming: u64 = 0;
+//         let mut outgoing: u64 = 0;
+
+//         let mut inputs_sum: u64 = 0;
+//         let mut outputs_sum: u64 = 0;
+
+//         // look for our own inputs
+//         for (i, input) in tx.input.iter().enumerate() {
+//             if let Some(previous_output) = database.get_previous_output(&input.previous_output)? {
+//                 inputs_sum += previous_output.value;
+
+//                 // this output is ours, we have a path to derive it
+//                 if let Some((keychain, _)) =
+//                     database.get_path_from_script_pubkey(&previous_output.script_pubkey)?
+//                 {
+//                     outgoing += previous_output.value;
+
+//                     debug!("{} input #{} is mine, setting utxo as spent", tx.txid(), i);
+//                     updates.set_utxo(&LocalUtxo {
+//                         outpoint: input.previous_output,
+//                         txout: previous_output.clone(),
+//                         keychain,
+//                         is_spent: true,
+//                     })?;
+//                 }
+//             }
+//         }
+
+//         for (i, output) in tx.output.iter().enumerate() {
+//             // to compute the fees later
+//             outputs_sum += output.value;
+
+//             // this output is ours, we have a path to derive it
+//             if let Some((keychain, child)) =
+//                 database.get_path_from_script_pubkey(&output.script_pubkey)?
+//             {
+//                 debug!("{} output #{} is mine, adding utxo", tx.txid(), i);
+//                 updates.set_utxo(&LocalUtxo {
+//                     outpoint: OutPoint::new(tx.txid(), i as u32),
+//                     txout: output.clone(),
+//                     keychain,
+//                     is_spent: false,
+//                 })?;
+//                 incoming += output.value;
+
+//                 if keychain == KeychainKind::Internal
+//                     && (internal_max_deriv.is_none() || child > internal_max_deriv.unwrap_or(0))
+//                 {
+//                     *internal_max_deriv = Some(child);
+//                 } else if keychain == KeychainKind::External
+//                     && (external_max_deriv.is_none() || child > external_max_deriv.unwrap_or(0))
+//                 {
+//                     *external_max_deriv = Some(child);
+//                 }
+//             }
+//         }
+
+//         if incoming > 0 || outgoing > 0 {
+//             let tx = TransactionDetails {
+//                 txid: tx.txid(),
+//                 transaction: Some(tx.clone()),
+//                 received: incoming,
+//                 sent: outgoing,
+//                 confirmation_time: BlockTime::new(height, timestamp),
+//                 fee: Some(inputs_sum.saturating_sub(outputs_sum)),
+//             };
+
+//             info!("Saving tx {}", tx.txid);
+//             updates.set_tx(&tx)?;
+//         }
+
+//         database.commit_batch(updates)?;
+
+//         Ok(())
+//     }
+// }
+
+// impl Blockchain for CompactFiltersBlockchain {
+//     fn get_capabilities(&self) -> HashSet<Capability> {
+//         vec![Capability::FullHistory].into_iter().collect()
+//     }
+
+//     fn broadcast(&self, tx: &Transaction) -> Result<(), Error> {
+//         self.peers[0].broadcast_tx(tx.clone())?;
+
+//         Ok(())
+//     }
+
+//     fn estimate_fee(&self, _target: usize) -> Result<FeeRate, Error> {
+//         // TODO
+//         Ok(FeeRate::default())
+//     }
+// }
+
+// impl GetHeight for CompactFiltersBlockchain {
+//     fn get_height(&self) -> Result<u32, Error> {
+//         Ok(self.headers.get_height()? as u32)
+//     }
+// }
+
+// impl GetTx for CompactFiltersBlockchain {
+//     fn get_tx(&self, txid: &Txid) -> Result<Option<Transaction>, Error> {
+//         Ok(self.peers[0]
+//             .get_mempool()
+//             .get_tx(&Inventory::Transaction(*txid)))
+//     }
+// }
+
+// impl GetBlockHash for CompactFiltersBlockchain {
+//     fn get_block_hash(&self, height: u64) -> Result<BlockHash, Error> {
+//         self.headers
+//             .get_block_hash(height as usize)?
+//             .ok_or(Error::CompactFilters(
+//                 CompactFiltersError::BlockHashNotFound,
+//             ))
+//     }
+// }
+
+// impl WalletSync for CompactFiltersBlockchain {
+//     #[allow(clippy::mutex_atomic)] // Mutex is easier to understand than a CAS loop.
+//     fn wallet_setup<D: BatchDatabase>(
+//         &self,
+//         database: &RefCell<D>,
+//         progress_update: Box<dyn Progress>,
+//     ) -> Result<(), Error> {
+//         let first_peer = &self.peers[0];
+
+//         let skip_blocks = self.skip_blocks.unwrap_or(0);
+
+//         let cf_sync = Arc::new(CfSync::new(Arc::clone(&self.headers), skip_blocks, 0x00)?);
+
+//         let initial_height = self.headers.get_height()?;
+//         let total_bundles = (first_peer.get_version().start_height as usize)
+//             .checked_sub(skip_blocks)
+//             .map(|x| x / 1000)
+//             .unwrap_or(0)
+//             + 1;
+//         let expected_bundles_to_sync = total_bundles.saturating_sub(cf_sync.pruned_bundles()?);
+
+//         let headers_cost = (first_peer.get_version().start_height as usize)
+//             .saturating_sub(initial_height) as f32
+//             * SYNC_HEADERS_COST;
+//         let filters_cost = expected_bundles_to_sync as f32 * SYNC_FILTERS_COST;
+
+//         let total_cost = headers_cost + filters_cost + PROCESS_BLOCKS_COST;
+
+//         if let Some(snapshot) = sync::sync_headers(
+//             Arc::clone(first_peer),
+//             Arc::clone(&self.headers),
+//             |new_height| {
+//                 let local_headers_cost =
+//                     new_height.saturating_sub(initial_height) as f32 * SYNC_HEADERS_COST;
+//                 progress_update.update(
+//                     local_headers_cost / total_cost * 100.0,
+//                     Some(format!("Synced headers to {}", new_height)),
+//                 )
+//             },
+//         )? {
+//             if snapshot.work()? > self.headers.work()? {
+//                 info!("Applying snapshot with work: {}", snapshot.work()?);
+//                 self.headers.apply_snapshot(snapshot)?;
+//             }
+//         }
+
+//         let synced_height = self.headers.get_height()?;
+//         let buried_height = synced_height.saturating_sub(sync::BURIED_CONFIRMATIONS);
+//         info!("Synced headers to height: {}", synced_height);
+
+//         cf_sync.prepare_sync(Arc::clone(first_peer))?;
+
+//         let mut database = database.borrow_mut();
+//         let database = database.deref_mut();
+
+//         let all_scripts = Arc::new(
+//             database
+//                 .iter_script_pubkeys(None)?
+//                 .into_iter()
+//                 .map(|s| s.to_bytes())
+//                 .collect::<Vec<_>>(),
+//         );
+
+//         #[allow(clippy::mutex_atomic)]
+//         let last_synced_block = Arc::new(Mutex::new(synced_height));
+
+//         let synced_bundles = Arc::new(AtomicUsize::new(0));
+//         let progress_update = Arc::new(Mutex::new(progress_update));
+
+//         let mut threads = Vec::with_capacity(self.peers.len());
+//         for peer in &self.peers {
+//             let cf_sync = Arc::clone(&cf_sync);
+//             let peer = Arc::clone(peer);
+//             let headers = Arc::clone(&self.headers);
+//             let all_scripts = Arc::clone(&all_scripts);
+//             let last_synced_block = Arc::clone(&last_synced_block);
+//             let progress_update = Arc::clone(&progress_update);
+//             let synced_bundles = Arc::clone(&synced_bundles);
+
+//             let thread = std::thread::spawn(move || {
+//                 cf_sync.capture_thread_for_sync(
+//                     peer,
+//                     |block_hash, filter| {
+//                         if !filter
+//                             .match_any(block_hash, &mut all_scripts.iter().map(AsRef::as_ref))?
+//                         {
+//                             return Ok(false);
+//                         }
+
+//                         let block_height = headers.get_height_for(block_hash)?.unwrap_or(0);
+//                         let saved_correct_block = matches!(headers.get_full_block(block_height)?, Some(block) if &block.block_hash() == block_hash);
+
+//                         if saved_correct_block {
+//                             Ok(false)
+//                         } else {
+//                             let mut last_synced_block = last_synced_block.lock().unwrap();
+
+//                             // If we download a block older than `last_synced_block`, we update it so that
+//                             // we know to delete and re-process all txs starting from that height
+//                             if block_height < *last_synced_block {
+//                                 *last_synced_block = block_height;
+//                             }
+
+//                             Ok(true)
+//                         }
+//                     },
+//                     |index| {
+//                         let synced_bundles = synced_bundles.fetch_add(1, Ordering::SeqCst);
+//                         let local_filters_cost = synced_bundles as f32 * SYNC_FILTERS_COST;
+//                         progress_update.lock().unwrap().update(
+//                             (headers_cost + local_filters_cost) / total_cost * 100.0,
+//                             Some(format!(
+//                                 "Synced filters {} - {}",
+//                                 index * 1000 + 1,
+//                                 (index + 1) * 1000
+//                             )),
+//                         )
+//                     },
+//                 )
+//             });
+
+//             threads.push(thread);
+//         }
+
+//         for t in threads {
+//             t.join().unwrap()?;
+//         }
+
+//         progress_update.lock().unwrap().update(
+//             (headers_cost + filters_cost) / total_cost * 100.0,
+//             Some("Processing downloaded blocks and mempool".into()),
+//         )?;
+
+//         // delete all txs newer than last_synced_block
+//         let last_synced_block = *last_synced_block.lock().unwrap();
+//         log::debug!(
+//             "Dropping transactions newer than `last_synced_block` = {}",
+//             last_synced_block
+//         );
+//         let mut updates = database.begin_batch();
+//         for details in database.iter_txs(false)? {
+//             match details.confirmation_time {
+//                 Some(c) if (c.height as usize) < last_synced_block => continue,
+//                 _ => updates.del_tx(&details.txid, false)?,
+//             };
+//         }
+//         database.commit_batch(updates)?;
+
+//         match first_peer.ask_for_mempool() {
+//             Err(CompactFiltersError::PeerBloomDisabled) => {
+//                 log::warn!("Peer has BLOOM disabled, we can't ask for the mempool")
+//             }
+//             e => e?,
+//         };
+
+//         let mut internal_max_deriv = None;
+//         let mut external_max_deriv = None;
+
+//         for (height, block) in self.headers.iter_full_blocks()? {
+//             for tx in &block.txdata {
+//                 self.process_tx(
+//                     database,
+//                     tx,
+//                     Some(height as u32),
+//                     None,
+//                     &mut internal_max_deriv,
+//                     &mut external_max_deriv,
+//                 )?;
+//             }
+//         }
+//         for tx in first_peer.get_mempool().iter_txs().iter() {
+//             self.process_tx(
+//                 database,
+//                 tx,
+//                 None,
+//                 None,
+//                 &mut internal_max_deriv,
+//                 &mut external_max_deriv,
+//             )?;
+//         }
+
+//         let current_ext = database
+//             .get_last_index(KeychainKind::External)?
+//             .unwrap_or(0);
+//         let first_ext_new = external_max_deriv.map(|x| x + 1).unwrap_or(0);
+//         if first_ext_new > current_ext {
+//             info!("Setting external index to {}", first_ext_new);
+//             database.set_last_index(KeychainKind::External, first_ext_new)?;
+//         }
+
+//         let current_int = database
+//             .get_last_index(KeychainKind::Internal)?
+//             .unwrap_or(0);
+//         let first_int_new = internal_max_deriv.map(|x| x + 1).unwrap_or(0);
+//         if first_int_new > current_int {
+//             info!("Setting internal index to {}", first_int_new);
+//             database.set_last_index(KeychainKind::Internal, first_int_new)?;
+//         }
+
+//         info!("Dropping blocks until {}", buried_height);
+//         self.headers.delete_blocks_until(buried_height)?;
+
+//         progress_update
+//             .lock()
+//             .unwrap()
+//             .update(100.0, Some("Done".into()))?;
+
+//         Ok(())
+//     }
+// }
+
+// /// Data to connect to a Bitcoin P2P peer
+// #[derive(Debug, serde::Deserialize, serde::Serialize, Clone, PartialEq, Eq)]
+// pub struct BitcoinPeerConfig {
+//     /// Peer address such as 127.0.0.1:18333
+//     pub address: String,
+//     /// Optional socks5 proxy
+//     pub socks5: Option<String>,
+//     /// Optional socks5 proxy credentials
+//     pub socks5_credentials: Option<(String, String)>,
+// }
+
+// /// Configuration for a [`CompactFiltersBlockchain`]
+// #[derive(Debug, serde::Deserialize, serde::Serialize, Clone, PartialEq, Eq)]
+// pub struct CompactFiltersBlockchainConfig {
+//     /// List of peers to try to connect to for asking headers and filters
+//     pub peers: Vec<BitcoinPeerConfig>,
+//     /// Network used
+//     pub network: Network,
+//     /// Storage dir to save partially downloaded headers and full blocks. Should be a separate directory per descriptor. Consider using [crate::wallet::wallet_name_from_descriptor] for this.
+//     pub storage_dir: String,
+//     /// Optionally skip initial `skip_blocks` blocks (default: 0)
+//     pub skip_blocks: Option<usize>,
+// }
+
+// impl ConfigurableBlockchain for CompactFiltersBlockchain {
+//     type Config = CompactFiltersBlockchainConfig;
+
+//     fn from_config(config: &Self::Config) -> Result<Self, Error> {
+//         let mempool = Arc::new(Mempool::default());
+//         let peers = config
+//             .peers
+//             .iter()
+//             .map(|peer_conf| match &peer_conf.socks5 {
+//                 None => Peer::connect(&peer_conf.address, Arc::clone(&mempool), config.network),
+//                 Some(proxy) => Peer::connect_proxy(
+//                     peer_conf.address.as_str(),
+//                     proxy,
+//                     peer_conf
+//                         .socks5_credentials
+//                         .as_ref()
+//                         .map(|(a, b)| (a.as_str(), b.as_str())),
+//                     Arc::clone(&mempool),
+//                     config.network,
+//                 ),
+//             })
+//             .collect::<Result<_, _>>()?;
+
+//         Ok(CompactFiltersBlockchain::new(
+//             peers,
+//             &config.storage_dir,
+//             config.skip_blocks,
+//         )?)
+//     }
+// }
+
+// /// An error that can occur during sync with a [`CompactFiltersBlockchain`]
+// #[derive(Debug)]
+// pub enum CompactFiltersError {
+//     /// A peer sent an invalid or unexpected response
+//     InvalidResponse,
+//     /// The headers returned are invalid
+//     InvalidHeaders,
+//     /// The compact filter headers returned are invalid
+//     InvalidFilterHeader,
+//     /// The compact filter returned is invalid
+//     InvalidFilter,
+//     /// The peer is missing a block in the valid chain
+//     MissingBlock,
+//     /// Block hash at specified height not found
+//     BlockHashNotFound,
+//     /// The data stored in the block filters storage are corrupted
+//     DataCorruption,
+
+//     /// A peer is not connected
+//     NotConnected,
+//     /// A peer took too long to reply to one of our messages
+//     Timeout,
+//     /// The peer doesn't advertise the [`BLOOM`](bitcoin::network::constants::ServiceFlags::BLOOM) service flag
+//     PeerBloomDisabled,
+
+//     /// No peers have been specified
+//     NoPeers,
+
+//     /// Internal database error
+//     Db(rocksdb::Error),
+//     /// Internal I/O error
+//     Io(std::io::Error),
+//     /// Invalid BIP158 filter
+//     Bip158(bitcoin::util::bip158::Error),
+//     /// Internal system time error
+//     Time(std::time::SystemTimeError),
+
+//     /// Wrapper for [`crate::error::Error`]
+//     Global(Box<crate::error::Error>),
+// }
+
+// impl fmt::Display for CompactFiltersError {
+//     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+//         match self {
+//             Self::InvalidResponse => write!(f, "A peer sent an invalid or unexpected response"),
+//             Self::InvalidHeaders => write!(f, "Invalid headers"),
+//             Self::InvalidFilterHeader => write!(f, "Invalid filter header"),
+//             Self::InvalidFilter => write!(f, "Invalid filters"),
+//             Self::MissingBlock => write!(f, "The peer is missing a block in the valid chain"),
+//             Self::BlockHashNotFound => write!(f, "Block hash not found"),
+//             Self::DataCorruption => write!(
+//                 f,
+//                 "The data stored in the block filters storage are corrupted"
+//             ),
+//             Self::NotConnected => write!(f, "A peer is not connected"),
+//             Self::Timeout => write!(f, "A peer took too long to reply to one of our messages"),
+//             Self::PeerBloomDisabled => write!(f, "Peer doesn't advertise the BLOOM service flag"),
+//             Self::NoPeers => write!(f, "No peers have been specified"),
+//             Self::Db(err) => write!(f, "Internal database error: {}", err),
+//             Self::Io(err) => write!(f, "Internal I/O error: {}", err),
+//             Self::Bip158(err) => write!(f, "Invalid BIP158 filter: {}", err),
+//             Self::Time(err) => write!(f, "Invalid system time: {}", err),
+//             Self::Global(err) => write!(f, "Generic error: {}", err),
+//         }
+//     }
+// }
+
+// impl std::error::Error for CompactFiltersError {}
+
+// impl_error!(rocksdb::Error, Db, CompactFiltersError);
+// impl_error!(std::io::Error, Io, CompactFiltersError);
+// impl_error!(bitcoin::util::bip158::Error, Bip158, CompactFiltersError);
+// impl_error!(std::time::SystemTimeError, Time, CompactFiltersError);
+
+// impl From<crate::error::Error> for CompactFiltersError {
+//     fn from(err: crate::error::Error) -> Self {
+//         CompactFiltersError::Global(Box::new(err))
+//     }
+// }
diff --git a/src/blockchain/compact_filters/peer.rs b/src/blockchain/compact_filters/peer.rs
index 665a033d4..98531afa0 100644
--- a/src/blockchain/compact_filters/peer.rs
+++ b/src/blockchain/compact_filters/peer.rs
@@ -1,576 +1,576 @@
-// Bitcoin Dev Kit
-// Written in 2020 by Alekos Filini <alekos.filini@gmail.com>
-//
-// Copyright (c) 2020-2021 Bitcoin Dev Kit Developers
-//
-// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
-// or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
-// You may not use this file except in accordance with one or both of these
-// licenses.
-
-use std::collections::HashMap;
-use std::io::BufReader;
-use std::net::{TcpStream, ToSocketAddrs};
-use std::sync::{Arc, Condvar, Mutex, RwLock};
-use std::thread;
-use std::time::{Duration, SystemTime, UNIX_EPOCH};
-
-use socks::{Socks5Stream, ToTargetAddr};
-
-use rand::{thread_rng, Rng};
-
-use bitcoin::consensus::{Decodable, Encodable};
-use bitcoin::hash_types::BlockHash;
-use bitcoin::network::constants::ServiceFlags;
-use bitcoin::network::message::{NetworkMessage, RawNetworkMessage};
-use bitcoin::network::message_blockdata::*;
-use bitcoin::network::message_filter::*;
-use bitcoin::network::message_network::VersionMessage;
-use bitcoin::network::Address;
-use bitcoin::{Block, Network, Transaction, Txid, Wtxid};
-
-use super::CompactFiltersError;
-
-type ResponsesMap = HashMap<&'static str, Arc<(Mutex<Vec<NetworkMessage>>, Condvar)>>;
-
-pub(crate) const TIMEOUT_SECS: u64 = 30;
-
-/// Container for unconfirmed, but valid Bitcoin transactions
-///
-/// It is normally shared between [`Peer`]s with the use of [`Arc`], so that transactions are not
-/// duplicated in memory.
-#[derive(Debug, Default)]
-pub struct Mempool(RwLock<InnerMempool>);
-
-#[derive(Debug, Default)]
-struct InnerMempool {
-    txs: HashMap<Txid, Transaction>,
-    wtxids: HashMap<Wtxid, Txid>,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-enum TxIdentifier {
-    Wtxid(Wtxid),
-    Txid(Txid),
-}
-
-impl Mempool {
-    /// Create a new empty mempool
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// Add a transaction to the mempool
-    ///
-    /// Note that this doesn't propagate the transaction to other
-    /// peers. To do that, [`broadcast`](crate::blockchain::Blockchain::broadcast) should be used.
-    pub fn add_tx(&self, tx: Transaction) {
-        let mut guard = self.0.write().unwrap();
-
-        guard.wtxids.insert(tx.wtxid(), tx.txid());
-        guard.txs.insert(tx.txid(), tx);
-    }
-
-    /// Look-up a transaction in the mempool given an [`Inventory`] request
-    pub fn get_tx(&self, inventory: &Inventory) -> Option<Transaction> {
-        let identifer = match inventory {
-            Inventory::Error
-            | Inventory::Block(_)
-            | Inventory::WitnessBlock(_)
-            | Inventory::CompactBlock(_) => return None,
-            Inventory::Transaction(txid) => TxIdentifier::Txid(*txid),
-            Inventory::WitnessTransaction(txid) => TxIdentifier::Txid(*txid),
-            Inventory::WTx(wtxid) => TxIdentifier::Wtxid(*wtxid),
-            Inventory::Unknown { inv_type, hash } => {
-                log::warn!(
-                    "Unknown inventory request type `{}`, hash `{:?}`",
-                    inv_type,
-                    hash
-                );
-                return None;
-            }
-        };
-
-        let txid = match identifer {
-            TxIdentifier::Txid(txid) => Some(txid),
-            TxIdentifier::Wtxid(wtxid) => self.0.read().unwrap().wtxids.get(&wtxid).cloned(),
-        };
-
-        txid.and_then(|txid| self.0.read().unwrap().txs.get(&txid).cloned())
-    }
-
-    /// Return whether or not the mempool contains a transaction with a given txid
-    pub fn has_tx(&self, txid: &Txid) -> bool {
-        self.0.read().unwrap().txs.contains_key(txid)
-    }
-
-    /// Return the list of transactions contained in the mempool
-    pub fn iter_txs(&self) -> Vec<Transaction> {
-        self.0.read().unwrap().txs.values().cloned().collect()
-    }
-}
-
-/// A Bitcoin peer
-#[derive(Debug)]
-#[allow(dead_code)]
-pub struct Peer {
-    writer: Arc<Mutex<TcpStream>>,
-    responses: Arc<RwLock<ResponsesMap>>,
-
-    reader_thread: thread::JoinHandle<()>,
-    connected: Arc<RwLock<bool>>,
-
-    mempool: Arc<Mempool>,
-
-    version: VersionMessage,
-    network: Network,
-}
-
-impl Peer {
-    /// Connect to a peer over a plaintext TCP connection
-    ///
-    /// This function internally spawns a new thread that will monitor incoming messages from the
-    /// peer, and optionally reply to some of them transparently, like [pings](bitcoin::network::message::NetworkMessage::Ping)
-    pub fn connect<A: ToSocketAddrs>(
-        address: A,
-        mempool: Arc<Mempool>,
-        network: Network,
-    ) -> Result<Self, CompactFiltersError> {
-        let stream = TcpStream::connect(address)?;
-
-        Peer::from_stream(stream, mempool, network)
-    }
-
-    /// Connect to a peer through a SOCKS5 proxy, optionally by using some credentials, specified
-    /// as a tuple of `(username, password)`
-    ///
-    /// This function internally spawns a new thread that will monitor incoming messages from the
-    /// peer, and optionally reply to some of them transparently, like [pings](NetworkMessage::Ping)
-    pub fn connect_proxy<T: ToTargetAddr, P: ToSocketAddrs>(
-        target: T,
-        proxy: P,
-        credentials: Option<(&str, &str)>,
-        mempool: Arc<Mempool>,
-        network: Network,
-    ) -> Result<Self, CompactFiltersError> {
-        let socks_stream = if let Some((username, password)) = credentials {
-            Socks5Stream::connect_with_password(proxy, target, username, password)?
-        } else {
-            Socks5Stream::connect(proxy, target)?
-        };
-
-        Peer::from_stream(socks_stream.into_inner(), mempool, network)
-    }
-
-    /// Create a [`Peer`] from an already connected TcpStream
-    fn from_stream(
-        stream: TcpStream,
-        mempool: Arc<Mempool>,
-        network: Network,
-    ) -> Result<Self, CompactFiltersError> {
-        let writer = Arc::new(Mutex::new(stream.try_clone()?));
-        let responses: Arc<RwLock<ResponsesMap>> = Arc::new(RwLock::new(HashMap::new()));
-        let connected = Arc::new(RwLock::new(true));
-
-        let mut locked_writer = writer.lock().unwrap();
-
-        let reader_thread_responses = Arc::clone(&responses);
-        let reader_thread_writer = Arc::clone(&writer);
-        let reader_thread_mempool = Arc::clone(&mempool);
-        let reader_thread_connected = Arc::clone(&connected);
-        let reader_thread = thread::spawn(move || {
-            Self::reader_thread(
-                network,
-                stream,
-                reader_thread_responses,
-                reader_thread_writer,
-                reader_thread_mempool,
-                reader_thread_connected,
-            )
-        });
-
-        let timestamp = SystemTime::now().duration_since(UNIX_EPOCH)?.as_secs() as i64;
-        let nonce = thread_rng().gen();
-        let receiver = Address::new(&locked_writer.peer_addr()?, ServiceFlags::NONE);
-        let sender = Address {
-            services: ServiceFlags::NONE,
-            address: [0u16; 8],
-            port: 0,
-        };
-
-        Self::_send(
-            &mut locked_writer,
-            network.magic(),
-            NetworkMessage::Version(VersionMessage::new(
-                ServiceFlags::WITNESS,
-                timestamp,
-                receiver,
-                sender,
-                nonce,
-                "MagicalBitcoinWallet".into(),
-                0,
-            )),
-        )?;
-        let version = if let NetworkMessage::Version(version) =
-            Self::_recv(&responses, "version", None).unwrap()
-        {
-            version
-        } else {
-            return Err(CompactFiltersError::InvalidResponse);
-        };
-
-        if let NetworkMessage::Verack = Self::_recv(&responses, "verack", None).unwrap() {
-            Self::_send(&mut locked_writer, network.magic(), NetworkMessage::Verack)?;
-        } else {
-            return Err(CompactFiltersError::InvalidResponse);
-        }
-
-        std::mem::drop(locked_writer);
-
-        Ok(Peer {
-            writer,
-            responses,
-            reader_thread,
-            connected,
-            mempool,
-            version,
-            network,
-        })
-    }
-
-    /// Send a Bitcoin network message
-    fn _send(
-        writer: &mut TcpStream,
-        magic: u32,
-        payload: NetworkMessage,
-    ) -> Result<(), CompactFiltersError> {
-        log::trace!("==> {:?}", payload);
-
-        let raw_message = RawNetworkMessage { magic, payload };
-
-        raw_message
-            .consensus_encode(writer)
-            .map_err(|_| CompactFiltersError::DataCorruption)?;
-
-        Ok(())
-    }
-
-    /// Wait for a specific incoming Bitcoin message, optionally with a timeout
-    fn _recv(
-        responses: &Arc<RwLock<ResponsesMap>>,
-        wait_for: &'static str,
-        timeout: Option<Duration>,
-    ) -> Option<NetworkMessage> {
-        let message_resp = {
-            let mut lock = responses.write().unwrap();
-            let message_resp = lock.entry(wait_for).or_default();
-            Arc::clone(message_resp)
-        };
-
-        let (lock, cvar) = &*message_resp;
-
-        let mut messages = lock.lock().unwrap();
-        while messages.is_empty() {
-            match timeout {
-                None => messages = cvar.wait(messages).unwrap(),
-                Some(t) => {
-                    let result = cvar.wait_timeout(messages, t).unwrap();
-                    if result.1.timed_out() {
-                        return None;
-                    }
-                    messages = result.0;
-                }
-            }
-        }
-
-        messages.pop()
-    }
-
-    /// Return the [`VersionMessage`] sent by the peer
-    pub fn get_version(&self) -> &VersionMessage {
-        &self.version
-    }
-
-    /// Return the Bitcoin [`Network`] in use
-    pub fn get_network(&self) -> Network {
-        self.network
-    }
-
-    /// Return the mempool used by this peer
-    pub fn get_mempool(&self) -> Arc<Mempool> {
-        Arc::clone(&self.mempool)
-    }
-
-    /// Return whether or not the peer is still connected
-    pub fn is_connected(&self) -> bool {
-        *self.connected.read().unwrap()
-    }
-
-    /// Internal function called once the `reader_thread` is spawned
-    fn reader_thread(
-        network: Network,
-        connection: TcpStream,
-        reader_thread_responses: Arc<RwLock<ResponsesMap>>,
-        reader_thread_writer: Arc<Mutex<TcpStream>>,
-        reader_thread_mempool: Arc<Mempool>,
-        reader_thread_connected: Arc<RwLock<bool>>,
-    ) {
-        macro_rules! check_disconnect {
-            ($call:expr) => {
-                match $call {
-                    Ok(good) => good,
-                    Err(e) => {
-                        log::debug!("Error {:?}", e);
-                        *reader_thread_connected.write().unwrap() = false;
-
-                        break;
-                    }
-                }
-            };
-        }
-
-        let mut reader = BufReader::new(connection);
-        loop {
-            let raw_message: RawNetworkMessage =
-                check_disconnect!(Decodable::consensus_decode(&mut reader));
-
-            let in_message = if raw_message.magic != network.magic() {
-                continue;
-            } else {
-                raw_message.payload
-            };
-
-            log::trace!("<== {:?}", in_message);
-
-            match in_message {
-                NetworkMessage::Ping(nonce) => {
-                    check_disconnect!(Self::_send(
-                        &mut reader_thread_writer.lock().unwrap(),
-                        network.magic(),
-                        NetworkMessage::Pong(nonce),
-                    ));
-
-                    continue;
-                }
-                NetworkMessage::Alert(_) => continue,
-                NetworkMessage::GetData(ref inv) => {
-                    let (found, not_found): (Vec<_>, Vec<_>) = inv
-                        .iter()
-                        .map(|item| (*item, reader_thread_mempool.get_tx(item)))
-                        .partition(|(_, d)| d.is_some());
-                    for (_, found_tx) in found {
-                        check_disconnect!(Self::_send(
-                            &mut reader_thread_writer.lock().unwrap(),
-                            network.magic(),
-                            NetworkMessage::Tx(found_tx.unwrap()),
-                        ));
-                    }
-
-                    if !not_found.is_empty() {
-                        check_disconnect!(Self::_send(
-                            &mut reader_thread_writer.lock().unwrap(),
-                            network.magic(),
-                            NetworkMessage::NotFound(
-                                not_found.into_iter().map(|(i, _)| i).collect(),
-                            ),
-                        ));
-                    }
-                }
-                _ => {}
-            }
-
-            let message_resp = {
-                let mut lock = reader_thread_responses.write().unwrap();
-                let message_resp = lock.entry(in_message.cmd()).or_default();
-                Arc::clone(message_resp)
-            };
-
-            let (lock, cvar) = &*message_resp;
-            let mut messages = lock.lock().unwrap();
-            messages.push(in_message);
-            cvar.notify_all();
-        }
-    }
-
-    /// Send a raw Bitcoin message to the peer
-    pub fn send(&self, payload: NetworkMessage) -> Result<(), CompactFiltersError> {
-        let mut writer = self.writer.lock().unwrap();
-        Self::_send(&mut writer, self.network.magic(), payload)
-    }
-
-    /// Waits for a specific incoming Bitcoin message, optionally with a timeout
-    pub fn recv(
-        &self,
-        wait_for: &'static str,
-        timeout: Option<Duration>,
-    ) -> Result<Option<NetworkMessage>, CompactFiltersError> {
-        Ok(Self::_recv(&self.responses, wait_for, timeout))
-    }
-}
-
-pub trait CompactFiltersPeer {
-    fn get_cf_checkpt(
-        &self,
-        filter_type: u8,
-        stop_hash: BlockHash,
-    ) -> Result<CFCheckpt, CompactFiltersError>;
-    fn get_cf_headers(
-        &self,
-        filter_type: u8,
-        start_height: u32,
-        stop_hash: BlockHash,
-    ) -> Result<CFHeaders, CompactFiltersError>;
-    fn get_cf_filters(
-        &self,
-        filter_type: u8,
-        start_height: u32,
-        stop_hash: BlockHash,
-    ) -> Result<(), CompactFiltersError>;
-    fn pop_cf_filter_resp(&self) -> Result<CFilter, CompactFiltersError>;
-}
-
-impl CompactFiltersPeer for Peer {
-    fn get_cf_checkpt(
-        &self,
-        filter_type: u8,
-        stop_hash: BlockHash,
-    ) -> Result<CFCheckpt, CompactFiltersError> {
-        self.send(NetworkMessage::GetCFCheckpt(GetCFCheckpt {
-            filter_type,
-            stop_hash,
-        }))?;
-
-        let response = self
-            .recv("cfcheckpt", Some(Duration::from_secs(TIMEOUT_SECS)))?
-            .ok_or(CompactFiltersError::Timeout)?;
-        let response = match response {
-            NetworkMessage::CFCheckpt(response) => response,
-            _ => return Err(CompactFiltersError::InvalidResponse),
-        };
-
-        if response.filter_type != filter_type {
-            return Err(CompactFiltersError::InvalidResponse);
-        }
-
-        Ok(response)
-    }
-
-    fn get_cf_headers(
-        &self,
-        filter_type: u8,
-        start_height: u32,
-        stop_hash: BlockHash,
-    ) -> Result<CFHeaders, CompactFiltersError> {
-        self.send(NetworkMessage::GetCFHeaders(GetCFHeaders {
-            filter_type,
-            start_height,
-            stop_hash,
-        }))?;
-
-        let response = self
-            .recv("cfheaders", Some(Duration::from_secs(TIMEOUT_SECS)))?
-            .ok_or(CompactFiltersError::Timeout)?;
-        let response = match response {
-            NetworkMessage::CFHeaders(response) => response,
-            _ => return Err(CompactFiltersError::InvalidResponse),
-        };
-
-        if response.filter_type != filter_type {
-            return Err(CompactFiltersError::InvalidResponse);
-        }
-
-        Ok(response)
-    }
-
-    fn pop_cf_filter_resp(&self) -> Result<CFilter, CompactFiltersError> {
-        let response = self
-            .recv("cfilter", Some(Duration::from_secs(TIMEOUT_SECS)))?
-            .ok_or(CompactFiltersError::Timeout)?;
-        let response = match response {
-            NetworkMessage::CFilter(response) => response,
-            _ => return Err(CompactFiltersError::InvalidResponse),
-        };
-
-        Ok(response)
-    }
-
-    fn get_cf_filters(
-        &self,
-        filter_type: u8,
-        start_height: u32,
-        stop_hash: BlockHash,
-    ) -> Result<(), CompactFiltersError> {
-        self.send(NetworkMessage::GetCFilters(GetCFilters {
-            filter_type,
-            start_height,
-            stop_hash,
-        }))?;
-
-        Ok(())
-    }
-}
-
-pub trait InvPeer {
-    fn get_block(&self, block_hash: BlockHash) -> Result<Option<Block>, CompactFiltersError>;
-    fn ask_for_mempool(&self) -> Result<(), CompactFiltersError>;
-    fn broadcast_tx(&self, tx: Transaction) -> Result<(), CompactFiltersError>;
-}
-
-impl InvPeer for Peer {
-    fn get_block(&self, block_hash: BlockHash) -> Result<Option<Block>, CompactFiltersError> {
-        self.send(NetworkMessage::GetData(vec![Inventory::WitnessBlock(
-            block_hash,
-        )]))?;
-
-        match self.recv("block", Some(Duration::from_secs(TIMEOUT_SECS)))? {
-            None => Ok(None),
-            Some(NetworkMessage::Block(response)) => Ok(Some(response)),
-            _ => Err(CompactFiltersError::InvalidResponse),
-        }
-    }
-
-    fn ask_for_mempool(&self) -> Result<(), CompactFiltersError> {
-        if !self.version.services.has(ServiceFlags::BLOOM) {
-            return Err(CompactFiltersError::PeerBloomDisabled);
-        }
-
-        self.send(NetworkMessage::MemPool)?;
-        let inv = match self.recv("inv", Some(Duration::from_secs(5)))? {
-            None => return Ok(()), // empty mempool
-            Some(NetworkMessage::Inv(inv)) => inv,
-            _ => return Err(CompactFiltersError::InvalidResponse),
-        };
-
-        let getdata = inv
-            .iter()
-            .cloned()
-            .filter(
-                |item| matches!(item, Inventory::Transaction(txid) if !self.mempool.has_tx(txid)),
-            )
-            .collect::<Vec<_>>();
-        let num_txs = getdata.len();
-        self.send(NetworkMessage::GetData(getdata))?;
-
-        for _ in 0..num_txs {
-            let tx = self
-                .recv("tx", Some(Duration::from_secs(TIMEOUT_SECS)))?
-                .ok_or(CompactFiltersError::Timeout)?;
-            let tx = match tx {
-                NetworkMessage::Tx(tx) => tx,
-                _ => return Err(CompactFiltersError::InvalidResponse),
-            };
-
-            self.mempool.add_tx(tx);
-        }
-
-        Ok(())
-    }
-
-    fn broadcast_tx(&self, tx: Transaction) -> Result<(), CompactFiltersError> {
-        self.mempool.add_tx(tx.clone());
-        self.send(NetworkMessage::Tx(tx))?;
-
-        Ok(())
-    }
-}
+// // Bitcoin Dev Kit
+// // Written in 2020 by Alekos Filini <alekos.filini@gmail.com>
+// //
+// // Copyright (c) 2020-2021 Bitcoin Dev Kit Developers
+// //
+// // This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
+// // or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
+// // You may not use this file except in accordance with one or both of these
+// // licenses.
+
+// use std::collections::HashMap;
+// use std::io::BufReader;
+// use std::net::{TcpStream, ToSocketAddrs};
+// use std::sync::{Arc, Condvar, Mutex, RwLock};
+// use std::thread;
+// use std::time::{Duration, SystemTime, UNIX_EPOCH};
+
+// use socks::{Socks5Stream, ToTargetAddr};
+
+// use rand::{thread_rng, Rng};
+
+// use bitcoin::consensus::{Decodable, Encodable};
+// use bitcoin::hash_types::BlockHash;
+// use bitcoin::network::constants::ServiceFlags;
+// use bitcoin::network::message::{NetworkMessage, RawNetworkMessage};
+// use bitcoin::network::message_blockdata::*;
+// use bitcoin::network::message_filter::*;
+// use bitcoin::network::message_network::VersionMessage;
+// use bitcoin::network::Address;
+// use bitcoin::{Block, Network, Transaction, Txid, Wtxid};
+
+// use super::CompactFiltersError;
+
+// type ResponsesMap = HashMap<&'static str, Arc<(Mutex<Vec<NetworkMessage>>, Condvar)>>;
+
+// pub(crate) const TIMEOUT_SECS: u64 = 30;
+
+// /// Container for unconfirmed, but valid Bitcoin transactions
+// ///
+// /// It is normally shared between [`Peer`]s with the use of [`Arc`], so that transactions are not
+// /// duplicated in memory.
+// #[derive(Debug, Default)]
+// pub struct Mempool(RwLock<InnerMempool>);
+
+// #[derive(Debug, Default)]
+// struct InnerMempool {
+//     txs: HashMap<Txid, Transaction>,
+//     wtxids: HashMap<Wtxid, Txid>,
+// }
+
+// #[derive(Debug, Clone, PartialEq, Eq)]
+// enum TxIdentifier {
+//     Wtxid(Wtxid),
+//     Txid(Txid),
+// }
+
+// impl Mempool {
+//     /// Create a new empty mempool
+//     pub fn new() -> Self {
+//         Self::default()
+//     }
+
+//     /// Add a transaction to the mempool
+//     ///
+//     /// Note that this doesn't propagate the transaction to other
+//     /// peers. To do that, [`broadcast`](crate::blockchain::Blockchain::broadcast) should be used.
+//     pub fn add_tx(&self, tx: Transaction) {
+//         let mut guard = self.0.write().unwrap();
+
+//         guard.wtxids.insert(tx.wtxid(), tx.txid());
+//         guard.txs.insert(tx.txid(), tx);
+//     }
+
+//     /// Look-up a transaction in the mempool given an [`Inventory`] request
+//     pub fn get_tx(&self, inventory: &Inventory) -> Option<Transaction> {
+//         let identifer = match inventory {
+//             Inventory::Error
+//             | Inventory::Block(_)
+//             | Inventory::WitnessBlock(_)
+//             | Inventory::CompactBlock(_) => return None,
+//             Inventory::Transaction(txid) => TxIdentifier::Txid(*txid),
+//             Inventory::WitnessTransaction(txid) => TxIdentifier::Txid(*txid),
+//             Inventory::WTx(wtxid) => TxIdentifier::Wtxid(*wtxid),
+//             Inventory::Unknown { inv_type, hash } => {
+//                 log::warn!(
+//                     "Unknown inventory request type `{}`, hash `{:?}`",
+//                     inv_type,
+//                     hash
+//                 );
+//                 return None;
+//             }
+//         };
+
+//         let txid = match identifer {
+//             TxIdentifier::Txid(txid) => Some(txid),
+//             TxIdentifier::Wtxid(wtxid) => self.0.read().unwrap().wtxids.get(&wtxid).cloned(),
+//         };
+
+//         txid.and_then(|txid| self.0.read().unwrap().txs.get(&txid).cloned())
+//     }
+
+//     /// Return whether or not the mempool contains a transaction with a given txid
+//     pub fn has_tx(&self, txid: &Txid) -> bool {
+//         self.0.read().unwrap().txs.contains_key(txid)
+//     }
+
+//     /// Return the list of transactions contained in the mempool
+//     pub fn iter_txs(&self) -> Vec<Transaction> {
+//         self.0.read().unwrap().txs.values().cloned().collect()
+//     }
+// }
+
+// /// A Bitcoin peer
+// #[derive(Debug)]
+// #[allow(dead_code)]
+// pub struct Peer {
+//     writer: Arc<Mutex<TcpStream>>,
+//     responses: Arc<RwLock<ResponsesMap>>,
+
+//     reader_thread: thread::JoinHandle<()>,
+//     connected: Arc<RwLock<bool>>,
+
+//     mempool: Arc<Mempool>,
+
+//     version: VersionMessage,
+//     network: Network,
+// }
+
+// impl Peer {
+//     /// Connect to a peer over a plaintext TCP connection
+//     ///
+//     /// This function internally spawns a new thread that will monitor incoming messages from the
+//     /// peer, and optionally reply to some of them transparently, like [pings](bitcoin::network::message::NetworkMessage::Ping)
+//     pub fn connect<A: ToSocketAddrs>(
+//         address: A,
+//         mempool: Arc<Mempool>,
+//         network: Network,
+//     ) -> Result<Self, CompactFiltersError> {
+//         let stream = TcpStream::connect(address)?;
+
+//         Peer::from_stream(stream, mempool, network)
+//     }
+
+//     /// Connect to a peer through a SOCKS5 proxy, optionally by using some credentials, specified
+//     /// as a tuple of `(username, password)`
+//     ///
+//     /// This function internally spawns a new thread that will monitor incoming messages from the
+//     /// peer, and optionally reply to some of them transparently, like [pings](NetworkMessage::Ping)
+//     pub fn connect_proxy<T: ToTargetAddr, P: ToSocketAddrs>(
+//         target: T,
+//         proxy: P,
+//         credentials: Option<(&str, &str)>,
+//         mempool: Arc<Mempool>,
+//         network: Network,
+//     ) -> Result<Self, CompactFiltersError> {
+//         let socks_stream = if let Some((username, password)) = credentials {
+//             Socks5Stream::connect_with_password(proxy, target, username, password)?
+//         } else {
+//             Socks5Stream::connect(proxy, target)?
+//         };
+
+//         Peer::from_stream(socks_stream.into_inner(), mempool, network)
+//     }
+
+//     /// Create a [`Peer`] from an already connected TcpStream
+//     fn from_stream(
+//         stream: TcpStream,
+//         mempool: Arc<Mempool>,
+//         network: Network,
+//     ) -> Result<Self, CompactFiltersError> {
+//         let writer = Arc::new(Mutex::new(stream.try_clone()?));
+//         let responses: Arc<RwLock<ResponsesMap>> = Arc::new(RwLock::new(HashMap::new()));
+//         let connected = Arc::new(RwLock::new(true));
+
+//         let mut locked_writer = writer.lock().unwrap();
+
+//         let reader_thread_responses = Arc::clone(&responses);
+//         let reader_thread_writer = Arc::clone(&writer);
+//         let reader_thread_mempool = Arc::clone(&mempool);
+//         let reader_thread_connected = Arc::clone(&connected);
+//         let reader_thread = thread::spawn(move || {
+//             Self::reader_thread(
+//                 network,
+//                 stream,
+//                 reader_thread_responses,
+//                 reader_thread_writer,
+//                 reader_thread_mempool,
+//                 reader_thread_connected,
+//             )
+//         });
+
+//         let timestamp = SystemTime::now().duration_since(UNIX_EPOCH)?.as_secs() as i64;
+//         let nonce = thread_rng().gen();
+//         let receiver = Address::new(&locked_writer.peer_addr()?, ServiceFlags::NONE);
+//         let sender = Address {
+//             services: ServiceFlags::NONE,
+//             address: [0u16; 8],
+//             port: 0,
+//         };
+
+//         Self::_send(
+//             &mut locked_writer,
+//             network.magic(),
+//             NetworkMessage::Version(VersionMessage::new(
+//                 ServiceFlags::WITNESS,
+//                 timestamp,
+//                 receiver,
+//                 sender,
+//                 nonce,
+//                 "MagicalBitcoinWallet".into(),
+//                 0,
+//             )),
+//         )?;
+//         let version = if let NetworkMessage::Version(version) =
+//             Self::_recv(&responses, "version", None).unwrap()
+//         {
+//             version
+//         } else {
+//             return Err(CompactFiltersError::InvalidResponse);
+//         };
+
+//         if let NetworkMessage::Verack = Self::_recv(&responses, "verack", None).unwrap() {
+//             Self::_send(&mut locked_writer, network.magic(), NetworkMessage::Verack)?;
+//         } else {
+//             return Err(CompactFiltersError::InvalidResponse);
+//         }
+
+//         std::mem::drop(locked_writer);
+
+//         Ok(Peer {
+//             writer,
+//             responses,
+//             reader_thread,
+//             connected,
+//             mempool,
+//             version,
+//             network,
+//         })
+//     }
+
+//     /// Send a Bitcoin network message
+//     fn _send(
+//         writer: &mut TcpStream,
+//         magic: u32,
+//         payload: NetworkMessage,
+//     ) -> Result<(), CompactFiltersError> {
+//         log::trace!("==> {:?}", payload);
+
+//         let raw_message = RawNetworkMessage { magic, payload };
+
+//         raw_message
+//             .consensus_encode(writer)
+//             .map_err(|_| CompactFiltersError::DataCorruption)?;
+
+//         Ok(())
+//     }
+
+//     /// Wait for a specific incoming Bitcoin message, optionally with a timeout
+//     fn _recv(
+//         responses: &Arc<RwLock<ResponsesMap>>,
+//         wait_for: &'static str,
+//         timeout: Option<Duration>,
+//     ) -> Option<NetworkMessage> {
+//         let message_resp = {
+//             let mut lock = responses.write().unwrap();
+//             let message_resp = lock.entry(wait_for).or_default();
+//             Arc::clone(message_resp)
+//         };
+
+//         let (lock, cvar) = &*message_resp;
+
+//         let mut messages = lock.lock().unwrap();
+//         while messages.is_empty() {
+//             match timeout {
+//                 None => messages = cvar.wait(messages).unwrap(),
+//                 Some(t) => {
+//                     let result = cvar.wait_timeout(messages, t).unwrap();
+//                     if result.1.timed_out() {
+//                         return None;
+//                     }
+//                     messages = result.0;
+//                 }
+//             }
+//         }
+
+//         messages.pop()
+//     }
+
+//     /// Return the [`VersionMessage`] sent by the peer
+//     pub fn get_version(&self) -> &VersionMessage {
+//         &self.version
+//     }
+
+//     /// Return the Bitcoin [`Network`] in use
+//     pub fn get_network(&self) -> Network {
+//         self.network
+//     }
+
+//     /// Return the mempool used by this peer
+//     pub fn get_mempool(&self) -> Arc<Mempool> {
+//         Arc::clone(&self.mempool)
+//     }
+
+//     /// Return whether or not the peer is still connected
+//     pub fn is_connected(&self) -> bool {
+//         *self.connected.read().unwrap()
+//     }
+
+//     /// Internal function called once the `reader_thread` is spawned
+//     fn reader_thread(
+//         network: Network,
+//         connection: TcpStream,
+//         reader_thread_responses: Arc<RwLock<ResponsesMap>>,
+//         reader_thread_writer: Arc<Mutex<TcpStream>>,
+//         reader_thread_mempool: Arc<Mempool>,
+//         reader_thread_connected: Arc<RwLock<bool>>,
+//     ) {
+//         macro_rules! check_disconnect {
+//             ($call:expr) => {
+//                 match $call {
+//                     Ok(good) => good,
+//                     Err(e) => {
+//                         log::debug!("Error {:?}", e);
+//                         *reader_thread_connected.write().unwrap() = false;
+
+//                         break;
+//                     }
+//                 }
+//             };
+//         }
+
+//         let mut reader = BufReader::new(connection);
+//         loop {
+//             let raw_message: RawNetworkMessage =
+//                 check_disconnect!(Decodable::consensus_decode(&mut reader));
+
+//             let in_message = if raw_message.magic != network.magic() {
+//                 continue;
+//             } else {
+//                 raw_message.payload
+//             };
+
+//             log::trace!("<== {:?}", in_message);
+
+//             match in_message {
+//                 NetworkMessage::Ping(nonce) => {
+//                     check_disconnect!(Self::_send(
+//                         &mut reader_thread_writer.lock().unwrap(),
+//                         network.magic(),
+//                         NetworkMessage::Pong(nonce),
+//                     ));
+
+//                     continue;
+//                 }
+//                 NetworkMessage::Alert(_) => continue,
+//                 NetworkMessage::GetData(ref inv) => {
+//                     let (found, not_found): (Vec<_>, Vec<_>) = inv
+//                         .iter()
+//                         .map(|item| (*item, reader_thread_mempool.get_tx(item)))
+//                         .partition(|(_, d)| d.is_some());
+//                     for (_, found_tx) in found {
+//                         check_disconnect!(Self::_send(
+//                             &mut reader_thread_writer.lock().unwrap(),
+//                             network.magic(),
+//                             NetworkMessage::Tx(found_tx.unwrap()),
+//                         ));
+//                     }
+
+//                     if !not_found.is_empty() {
+//                         check_disconnect!(Self::_send(
+//                             &mut reader_thread_writer.lock().unwrap(),
+//                             network.magic(),
+//                             NetworkMessage::NotFound(
+//                                 not_found.into_iter().map(|(i, _)| i).collect(),
+//                             ),
+//                         ));
+//                     }
+//                 }
+//                 _ => {}
+//             }
+
+//             let message_resp = {
+//                 let mut lock = reader_thread_responses.write().unwrap();
+//                 let message_resp = lock.entry(in_message.cmd()).or_default();
+//                 Arc::clone(message_resp)
+//             };
+
+//             let (lock, cvar) = &*message_resp;
+//             let mut messages = lock.lock().unwrap();
+//             messages.push(in_message);
+//             cvar.notify_all();
+//         }
+//     }
+
+//     /// Send a raw Bitcoin message to the peer
+//     pub fn send(&self, payload: NetworkMessage) -> Result<(), CompactFiltersError> {
+//         let mut writer = self.writer.lock().unwrap();
+//         Self::_send(&mut writer, self.network.magic(), payload)
+//     }
+
+//     /// Waits for a specific incoming Bitcoin message, optionally with a timeout
+//     pub fn recv(
+//         &self,
+//         wait_for: &'static str,
+//         timeout: Option<Duration>,
+//     ) -> Result<Option<NetworkMessage>, CompactFiltersError> {
+//         Ok(Self::_recv(&self.responses, wait_for, timeout))
+//     }
+// }
+
+// pub trait CompactFiltersPeer {
+//     fn get_cf_checkpt(
+//         &self,
+//         filter_type: u8,
+//         stop_hash: BlockHash,
+//     ) -> Result<CFCheckpt, CompactFiltersError>;
+//     fn get_cf_headers(
+//         &self,
+//         filter_type: u8,
+//         start_height: u32,
+//         stop_hash: BlockHash,
+//     ) -> Result<CFHeaders, CompactFiltersError>;
+//     fn get_cf_filters(
+//         &self,
+//         filter_type: u8,
+//         start_height: u32,
+//         stop_hash: BlockHash,
+//     ) -> Result<(), CompactFiltersError>;
+//     fn pop_cf_filter_resp(&self) -> Result<CFilter, CompactFiltersError>;
+// }
+
+// impl CompactFiltersPeer for Peer {
+//     fn get_cf_checkpt(
+//         &self,
+//         filter_type: u8,
+//         stop_hash: BlockHash,
+//     ) -> Result<CFCheckpt, CompactFiltersError> {
+//         self.send(NetworkMessage::GetCFCheckpt(GetCFCheckpt {
+//             filter_type,
+//             stop_hash,
+//         }))?;
+
+//         let response = self
+//             .recv("cfcheckpt", Some(Duration::from_secs(TIMEOUT_SECS)))?
+//             .ok_or(CompactFiltersError::Timeout)?;
+//         let response = match response {
+//             NetworkMessage::CFCheckpt(response) => response,
+//             _ => return Err(CompactFiltersError::InvalidResponse),
+//         };
+
+//         if response.filter_type != filter_type {
+//             return Err(CompactFiltersError::InvalidResponse);
+//         }
+
+//         Ok(response)
+//     }
+
+//     fn get_cf_headers(
+//         &self,
+//         filter_type: u8,
+//         start_height: u32,
+//         stop_hash: BlockHash,
+//     ) -> Result<CFHeaders, CompactFiltersError> {
+//         self.send(NetworkMessage::GetCFHeaders(GetCFHeaders {
+//             filter_type,
+//             start_height,
+//             stop_hash,
+//         }))?;
+
+//         let response = self
+//             .recv("cfheaders", Some(Duration::from_secs(TIMEOUT_SECS)))?
+//             .ok_or(CompactFiltersError::Timeout)?;
+//         let response = match response {
+//             NetworkMessage::CFHeaders(response) => response,
+//             _ => return Err(CompactFiltersError::InvalidResponse),
+//         };
+
+//         if response.filter_type != filter_type {
+//             return Err(CompactFiltersError::InvalidResponse);
+//         }
+
+//         Ok(response)
+//     }
+
+//     fn pop_cf_filter_resp(&self) -> Result<CFilter, CompactFiltersError> {
+//         let response = self
+//             .recv("cfilter", Some(Duration::from_secs(TIMEOUT_SECS)))?
+//             .ok_or(CompactFiltersError::Timeout)?;
+//         let response = match response {
+//             NetworkMessage::CFilter(response) => response,
+//             _ => return Err(CompactFiltersError::InvalidResponse),
+//         };
+
+//         Ok(response)
+//     }
+
+//     fn get_cf_filters(
+//         &self,
+//         filter_type: u8,
+//         start_height: u32,
+//         stop_hash: BlockHash,
+//     ) -> Result<(), CompactFiltersError> {
+//         self.send(NetworkMessage::GetCFilters(GetCFilters {
+//             filter_type,
+//             start_height,
+//             stop_hash,
+//         }))?;
+
+//         Ok(())
+//     }
+// }
+
+// pub trait InvPeer {
+//     fn get_block(&self, block_hash: BlockHash) -> Result<Option<Block>, CompactFiltersError>;
+//     fn ask_for_mempool(&self) -> Result<(), CompactFiltersError>;
+//     fn broadcast_tx(&self, tx: Transaction) -> Result<(), CompactFiltersError>;
+// }
+
+// impl InvPeer for Peer {
+//     fn get_block(&self, block_hash: BlockHash) -> Result<Option<Block>, CompactFiltersError> {
+//         self.send(NetworkMessage::GetData(vec![Inventory::WitnessBlock(
+//             block_hash,
+//         )]))?;
+
+//         match self.recv("block", Some(Duration::from_secs(TIMEOUT_SECS)))? {
+//             None => Ok(None),
+//             Some(NetworkMessage::Block(response)) => Ok(Some(response)),
+//             _ => Err(CompactFiltersError::InvalidResponse),
+//         }
+//     }
+
+//     fn ask_for_mempool(&self) -> Result<(), CompactFiltersError> {
+//         if !self.version.services.has(ServiceFlags::BLOOM) {
+//             return Err(CompactFiltersError::PeerBloomDisabled);
+//         }
+
+//         self.send(NetworkMessage::MemPool)?;
+//         let inv = match self.recv("inv", Some(Duration::from_secs(5)))? {
+//             None => return Ok(()), // empty mempool
+//             Some(NetworkMessage::Inv(inv)) => inv,
+//             _ => return Err(CompactFiltersError::InvalidResponse),
+//         };
+
+//         let getdata = inv
+//             .iter()
+//             .cloned()
+//             .filter(
+//                 |item| matches!(item, Inventory::Transaction(txid) if !self.mempool.has_tx(txid)),
+//             )
+//             .collect::<Vec<_>>();
+//         let num_txs = getdata.len();
+//         self.send(NetworkMessage::GetData(getdata))?;
+
+//         for _ in 0..num_txs {
+//             let tx = self
+//                 .recv("tx", Some(Duration::from_secs(TIMEOUT_SECS)))?
+//                 .ok_or(CompactFiltersError::Timeout)?;
+//             let tx = match tx {
+//                 NetworkMessage::Tx(tx) => tx,
+//                 _ => return Err(CompactFiltersError::InvalidResponse),
+//             };
+
+//             self.mempool.add_tx(tx);
+//         }
+
+//         Ok(())
+//     }
+
+//     fn broadcast_tx(&self, tx: Transaction) -> Result<(), CompactFiltersError> {
+//         self.mempool.add_tx(tx.clone());
+//         self.send(NetworkMessage::Tx(tx))?;
+
+//         Ok(())
+//     }
+// }
diff --git a/src/blockchain/compact_filters/store.rs b/src/blockchain/compact_filters/store.rs
index 6b8d4943b..9b42a1909 100644
--- a/src/blockchain/compact_filters/store.rs
+++ b/src/blockchain/compact_filters/store.rs
@@ -1,836 +1,836 @@
-// Bitcoin Dev Kit
-// Written in 2020 by Alekos Filini <alekos.filini@gmail.com>
-//
-// Copyright (c) 2020-2021 Bitcoin Dev Kit Developers
-//
-// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
-// or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
-// You may not use this file except in accordance with one or both of these
-// licenses.
-
-use std::convert::TryInto;
-use std::fmt;
-use std::io::{Read, Write};
-use std::marker::PhantomData;
-use std::sync::Arc;
-use std::sync::RwLock;
-
-use rand::distributions::Alphanumeric;
-use rand::{thread_rng, Rng};
-
-use rocksdb::{Direction, IteratorMode, ReadOptions, WriteBatch, DB};
-
-use bitcoin::blockdata::constants::genesis_block;
-use bitcoin::consensus::{deserialize, encode::VarInt, serialize, Decodable, Encodable};
-use bitcoin::hash_types::{FilterHash, FilterHeader};
-use bitcoin::hashes::Hash;
-use bitcoin::util::bip158::BlockFilter;
-use bitcoin::util::uint::Uint256;
-use bitcoin::Block;
-use bitcoin::BlockHash;
-use bitcoin::BlockHeader;
-use bitcoin::Network;
-
-use super::CompactFiltersError;
-
-pub trait StoreType: Default + fmt::Debug {}
-
-#[derive(Default, Debug)]
-pub struct Full;
-impl StoreType for Full {}
-#[derive(Default, Debug)]
-pub struct Snapshot;
-impl StoreType for Snapshot {}
-
-pub enum StoreEntry {
-    BlockHeader(Option<usize>),
-    Block(Option<usize>),
-    BlockHeaderIndex(Option<BlockHash>),
-    CFilterTable((u8, Option<usize>)),
-}
-
-impl StoreEntry {
-    pub fn get_prefix(&self) -> Vec<u8> {
-        match self {
-            StoreEntry::BlockHeader(_) => b"z",
-            StoreEntry::Block(_) => b"x",
-            StoreEntry::BlockHeaderIndex(_) => b"i",
-            StoreEntry::CFilterTable(_) => b"t",
-        }
-        .to_vec()
-    }
-
-    pub fn get_key(&self) -> Vec<u8> {
-        let mut prefix = self.get_prefix();
-        match self {
-            StoreEntry::BlockHeader(Some(height)) => {
-                prefix.extend_from_slice(&height.to_be_bytes())
-            }
-            StoreEntry::Block(Some(height)) => prefix.extend_from_slice(&height.to_be_bytes()),
-            StoreEntry::BlockHeaderIndex(Some(hash)) => {
-                prefix.extend_from_slice(&hash.into_inner())
-            }
-            StoreEntry::CFilterTable((filter_type, bundle_index)) => {
-                prefix.push(*filter_type);
-                if let Some(bundle_index) = bundle_index {
-                    prefix.extend_from_slice(&bundle_index.to_be_bytes());
-                }
-            }
-            _ => {}
-        }
-
-        prefix
-    }
-}
-
-pub trait SerializeDb: Sized {
-    fn serialize(&self) -> Vec<u8>;
-    fn deserialize(data: &[u8]) -> Result<Self, CompactFiltersError>;
-}
-
-impl<T> SerializeDb for T
-where
-    T: Encodable + Decodable,
-{
-    fn serialize(&self) -> Vec<u8> {
-        serialize(self)
-    }
-
-    fn deserialize(data: &[u8]) -> Result<Self, CompactFiltersError> {
-        deserialize(data).map_err(|_| CompactFiltersError::DataCorruption)
-    }
-}
-
-impl Encodable for BundleStatus {
-    fn consensus_encode<W: Write + ?Sized>(&self, e: &mut W) -> Result<usize, std::io::Error> {
-        let mut written = 0;
-
-        match self {
-            BundleStatus::Init => {
-                written += 0x00u8.consensus_encode(e)?;
-            }
-            BundleStatus::CfHeaders { cf_headers } => {
-                written += 0x01u8.consensus_encode(e)?;
-                written += VarInt(cf_headers.len() as u64).consensus_encode(e)?;
-                for header in cf_headers {
-                    written += header.consensus_encode(e)?;
-                }
-            }
-            BundleStatus::CFilters { cf_filters } => {
-                written += 0x02u8.consensus_encode(e)?;
-                written += VarInt(cf_filters.len() as u64).consensus_encode(e)?;
-                for filter in cf_filters {
-                    written += filter.consensus_encode(e)?;
-                }
-            }
-            BundleStatus::Processed { cf_filters } => {
-                written += 0x03u8.consensus_encode(e)?;
-                written += VarInt(cf_filters.len() as u64).consensus_encode(e)?;
-                for filter in cf_filters {
-                    written += filter.consensus_encode(e)?;
-                }
-            }
-            BundleStatus::Pruned => {
-                written += 0x04u8.consensus_encode(e)?;
-            }
-            BundleStatus::Tip { cf_filters } => {
-                written += 0x05u8.consensus_encode(e)?;
-                written += VarInt(cf_filters.len() as u64).consensus_encode(e)?;
-                for filter in cf_filters {
-                    written += filter.consensus_encode(e)?;
-                }
-            }
-        }
-
-        Ok(written)
-    }
-}
-
-impl Decodable for BundleStatus {
-    fn consensus_decode<D: Read + ?Sized>(
-        d: &mut D,
-    ) -> Result<Self, bitcoin::consensus::encode::Error> {
-        let byte_type = u8::consensus_decode(d)?;
-        match byte_type {
-            0x00 => Ok(BundleStatus::Init),
-            0x01 => {
-                let num = VarInt::consensus_decode(d)?;
-                let num = num.0 as usize;
-
-                let mut cf_headers = Vec::with_capacity(num);
-                for _ in 0..num {
-                    cf_headers.push(FilterHeader::consensus_decode(d)?);
-                }
-
-                Ok(BundleStatus::CfHeaders { cf_headers })
-            }
-            0x02 => {
-                let num = VarInt::consensus_decode(d)?;
-                let num = num.0 as usize;
-
-                let mut cf_filters = Vec::with_capacity(num);
-                for _ in 0..num {
-                    cf_filters.push(Vec::<u8>::consensus_decode(d)?);
-                }
-
-                Ok(BundleStatus::CFilters { cf_filters })
-            }
-            0x03 => {
-                let num = VarInt::consensus_decode(d)?;
-                let num = num.0 as usize;
-
-                let mut cf_filters = Vec::with_capacity(num);
-                for _ in 0..num {
-                    cf_filters.push(Vec::<u8>::consensus_decode(d)?);
-                }
-
-                Ok(BundleStatus::Processed { cf_filters })
-            }
-            0x04 => Ok(BundleStatus::Pruned),
-            0x05 => {
-                let num = VarInt::consensus_decode(d)?;
-                let num = num.0 as usize;
-
-                let mut cf_filters = Vec::with_capacity(num);
-                for _ in 0..num {
-                    cf_filters.push(Vec::<u8>::consensus_decode(d)?);
-                }
-
-                Ok(BundleStatus::Tip { cf_filters })
-            }
-            _ => Err(bitcoin::consensus::encode::Error::ParseFailed(
-                "Invalid byte type",
-            )),
-        }
-    }
-}
-
-pub struct ChainStore<T: StoreType> {
-    store: Arc<RwLock<DB>>,
-    cf_name: String,
-    min_height: usize,
-    network: Network,
-    phantom: PhantomData<T>,
-}
-
-impl ChainStore<Full> {
-    pub fn new(store: DB, network: Network) -> Result<Self, CompactFiltersError> {
-        let genesis = genesis_block(network);
-
-        let cf_name = "default".to_string();
-        let cf_handle = store.cf_handle(&cf_name).unwrap();
-
-        let genesis_key = StoreEntry::BlockHeader(Some(0)).get_key();
-
-        if store.get_pinned_cf(cf_handle, &genesis_key)?.is_none() {
-            let mut batch = WriteBatch::default();
-            batch.put_cf(
-                cf_handle,
-                genesis_key,
-                (genesis.header, genesis.header.work()).serialize(),
-            );
-            batch.put_cf(
-                cf_handle,
-                StoreEntry::BlockHeaderIndex(Some(genesis.block_hash())).get_key(),
-                0usize.to_be_bytes(),
-            );
-            store.write(batch)?;
-        }
-
-        Ok(ChainStore {
-            store: Arc::new(RwLock::new(store)),
-            cf_name,
-            min_height: 0,
-            network,
-            phantom: PhantomData,
-        })
-    }
-
-    pub fn get_locators(&self) -> Result<Vec<(BlockHash, usize)>, CompactFiltersError> {
-        let mut step = 1;
-        let mut index = self.get_height()?;
-        let mut answer = Vec::new();
-
-        let store_read = self.store.read().unwrap();
-        let cf_handle = store_read.cf_handle(&self.cf_name).unwrap();
-
-        loop {
-            if answer.len() > 10 {
-                step *= 2;
-            }
-
-            let (header, _): (BlockHeader, Uint256) = SerializeDb::deserialize(
-                &store_read
-                    .get_pinned_cf(cf_handle, StoreEntry::BlockHeader(Some(index)).get_key())?
-                    .unwrap(),
-            )?;
-            answer.push((header.block_hash(), index));
-
-            if let Some(new_index) = index.checked_sub(step) {
-                index = new_index;
-            } else {
-                break;
-            }
-        }
-
-        Ok(answer)
-    }
-
-    pub fn start_snapshot(&self, from: usize) -> Result<ChainStore<Snapshot>, CompactFiltersError> {
-        let new_cf_name: String = thread_rng()
-            .sample_iter(&Alphanumeric)
-            .map(|byte| byte as char)
-            .take(16)
-            .collect();
-        let new_cf_name = format!("_headers:{}", new_cf_name);
-
-        let mut write_store = self.store.write().unwrap();
-
-        write_store.create_cf(&new_cf_name, &Default::default())?;
-
-        let cf_handle = write_store.cf_handle(&self.cf_name).unwrap();
-        let new_cf_handle = write_store.cf_handle(&new_cf_name).unwrap();
-
-        let (header, work): (BlockHeader, Uint256) = SerializeDb::deserialize(
-            &write_store
-                .get_pinned_cf(cf_handle, StoreEntry::BlockHeader(Some(from)).get_key())?
-                .ok_or(CompactFiltersError::DataCorruption)?,
-        )?;
-
-        let mut batch = WriteBatch::default();
-        batch.put_cf(
-            new_cf_handle,
-            StoreEntry::BlockHeaderIndex(Some(header.block_hash())).get_key(),
-            from.to_be_bytes(),
-        );
-        batch.put_cf(
-            new_cf_handle,
-            StoreEntry::BlockHeader(Some(from)).get_key(),
-            (header, work).serialize(),
-        );
-        write_store.write(batch)?;
-
-        let store = Arc::clone(&self.store);
-        Ok(ChainStore {
-            store,
-            cf_name: new_cf_name,
-            min_height: from,
-            network: self.network,
-            phantom: PhantomData,
-        })
-    }
-
-    pub fn recover_snapshot(&self, cf_name: &str) -> Result<(), CompactFiltersError> {
-        let mut write_store = self.store.write().unwrap();
-        let snapshot_cf_handle = write_store.cf_handle(cf_name).unwrap();
-
-        let prefix = StoreEntry::BlockHeader(None).get_key();
-        let mut iterator = write_store.prefix_iterator_cf(snapshot_cf_handle, prefix);
-
-        let min_height = match iterator
-            .next()
-            .and_then(|(k, _)| k[1..].try_into().ok())
-            .map(usize::from_be_bytes)
-        {
-            None => {
-                std::mem::drop(iterator);
-                write_store.drop_cf(cf_name).ok();
-
-                return Ok(());
-            }
-            Some(x) => x,
-        };
-        std::mem::drop(iterator);
-        std::mem::drop(write_store);
-
-        let snapshot = ChainStore {
-            store: Arc::clone(&self.store),
-            cf_name: cf_name.into(),
-            min_height,
-            network: self.network,
-            phantom: PhantomData,
-        };
-        if snapshot.work()? > self.work()? {
-            self.apply_snapshot(snapshot)?;
-        }
-
-        Ok(())
-    }
-
-    pub fn apply_snapshot(
-        &self,
-        snaphost: ChainStore<Snapshot>,
-    ) -> Result<(), CompactFiltersError> {
-        let mut batch = WriteBatch::default();
-
-        let read_store = self.store.read().unwrap();
-        let cf_handle = read_store.cf_handle(&self.cf_name).unwrap();
-        let snapshot_cf_handle = read_store.cf_handle(&snaphost.cf_name).unwrap();
-
-        let from_key = StoreEntry::BlockHeader(Some(snaphost.min_height)).get_key();
-        let to_key = StoreEntry::BlockHeader(Some(usize::MAX)).get_key();
-
-        let mut opts = ReadOptions::default();
-        opts.set_iterate_upper_bound(to_key.clone());
-
-        log::debug!("Removing items");
-        batch.delete_range_cf(cf_handle, &from_key, &to_key);
-        for (_, v) in read_store.iterator_cf_opt(
-            cf_handle,
-            opts,
-            IteratorMode::From(&from_key, Direction::Forward),
-        ) {
-            let (header, _): (BlockHeader, Uint256) = SerializeDb::deserialize(&v)?;
-
-            batch.delete_cf(
-                cf_handle,
-                StoreEntry::BlockHeaderIndex(Some(header.block_hash())).get_key(),
-            );
-        }
-
-        // Delete full blocks overridden by snapshot
-        let from_key = StoreEntry::Block(Some(snaphost.min_height)).get_key();
-        let to_key = StoreEntry::Block(Some(usize::MAX)).get_key();
-        batch.delete_range(&from_key, &to_key);
-
-        log::debug!("Copying over new items");
-        for (k, v) in read_store.iterator_cf(snapshot_cf_handle, IteratorMode::Start) {
-            batch.put_cf(cf_handle, k, v);
-        }
-
-        read_store.write(batch)?;
-        std::mem::drop(read_store);
-
-        self.store.write().unwrap().drop_cf(&snaphost.cf_name)?;
-
-        Ok(())
-    }
-
-    pub fn get_height_for(
-        &self,
-        block_hash: &BlockHash,
-    ) -> Result<Option<usize>, CompactFiltersError> {
-        let read_store = self.store.read().unwrap();
-        let cf_handle = read_store.cf_handle(&self.cf_name).unwrap();
-
-        let key = StoreEntry::BlockHeaderIndex(Some(*block_hash)).get_key();
-        let data = read_store.get_pinned_cf(cf_handle, key)?;
-        data.map(|data| {
-            Ok::<_, CompactFiltersError>(usize::from_be_bytes(
-                data.as_ref()
-                    .try_into()
-                    .map_err(|_| CompactFiltersError::DataCorruption)?,
-            ))
-        })
-        .transpose()
-    }
-
-    pub fn get_block_hash(&self, height: usize) -> Result<Option<BlockHash>, CompactFiltersError> {
-        let read_store = self.store.read().unwrap();
-        let cf_handle = read_store.cf_handle(&self.cf_name).unwrap();
-
-        let key = StoreEntry::BlockHeader(Some(height)).get_key();
-        let data = read_store.get_pinned_cf(cf_handle, key)?;
-        data.map(|data| {
-            let (header, _): (BlockHeader, Uint256) =
-                deserialize(&data).map_err(|_| CompactFiltersError::DataCorruption)?;
-            Ok::<_, CompactFiltersError>(header.block_hash())
-        })
-        .transpose()
-    }
-
-    pub fn save_full_block(&self, block: &Block, height: usize) -> Result<(), CompactFiltersError> {
-        let key = StoreEntry::Block(Some(height)).get_key();
-        self.store.read().unwrap().put(key, block.serialize())?;
-
-        Ok(())
-    }
-
-    pub fn get_full_block(&self, height: usize) -> Result<Option<Block>, CompactFiltersError> {
-        let read_store = self.store.read().unwrap();
-
-        let key = StoreEntry::Block(Some(height)).get_key();
-        let opt_block = read_store.get_pinned(key)?;
-
-        opt_block
-            .map(|data| deserialize(&data))
-            .transpose()
-            .map_err(|_| CompactFiltersError::DataCorruption)
-    }
-
-    pub fn delete_blocks_until(&self, height: usize) -> Result<(), CompactFiltersError> {
-        let from_key = StoreEntry::Block(Some(0)).get_key();
-        let to_key = StoreEntry::Block(Some(height)).get_key();
-
-        let mut batch = WriteBatch::default();
-        batch.delete_range(&from_key, &to_key);
-
-        self.store.read().unwrap().write(batch)?;
-
-        Ok(())
-    }
-
-    pub fn iter_full_blocks(&self) -> Result<Vec<(usize, Block)>, CompactFiltersError> {
-        let read_store = self.store.read().unwrap();
-
-        let prefix = StoreEntry::Block(None).get_key();
-
-        let iterator = read_store.prefix_iterator(&prefix);
-        // FIXME: we have to filter manually because rocksdb sometimes returns stuff that doesn't
-        // have the right prefix
-        iterator
-            .filter(|(k, _)| k.starts_with(&prefix))
-            .map(|(k, v)| {
-                let height: usize = usize::from_be_bytes(
-                    k[1..]
-                        .try_into()
-                        .map_err(|_| CompactFiltersError::DataCorruption)?,
-                );
-                let block = SerializeDb::deserialize(&v)?;
-
-                Ok((height, block))
-            })
-            .collect::<Result<_, _>>()
-    }
-}
-
-impl<T: StoreType> ChainStore<T> {
-    pub fn work(&self) -> Result<Uint256, CompactFiltersError> {
-        let read_store = self.store.read().unwrap();
-        let cf_handle = read_store.cf_handle(&self.cf_name).unwrap();
-
-        let prefix = StoreEntry::BlockHeader(None).get_key();
-        let iterator = read_store.prefix_iterator_cf(cf_handle, prefix);
-
-        Ok(iterator
-            .last()
-            .map(|(_, v)| -> Result<_, CompactFiltersError> {
-                let (_, work): (BlockHeader, Uint256) = SerializeDb::deserialize(&v)?;
-
-                Ok(work)
-            })
-            .transpose()?
-            .unwrap_or_default())
-    }
-
-    pub fn get_height(&self) -> Result<usize, CompactFiltersError> {
-        let read_store = self.store.read().unwrap();
-        let cf_handle = read_store.cf_handle(&self.cf_name).unwrap();
-
-        let prefix = StoreEntry::BlockHeader(None).get_key();
-        let iterator = read_store.prefix_iterator_cf(cf_handle, prefix);
-
-        Ok(iterator
-            .last()
-            .map(|(k, _)| -> Result<_, CompactFiltersError> {
-                let height = usize::from_be_bytes(
-                    k[1..]
-                        .try_into()
-                        .map_err(|_| CompactFiltersError::DataCorruption)?,
-                );
-
-                Ok(height)
-            })
-            .transpose()?
-            .unwrap_or_default())
-    }
-
-    pub fn get_tip_hash(&self) -> Result<Option<BlockHash>, CompactFiltersError> {
-        let read_store = self.store.read().unwrap();
-        let cf_handle = read_store.cf_handle(&self.cf_name).unwrap();
-
-        let prefix = StoreEntry::BlockHeader(None).get_key();
-        let iterator = read_store.prefix_iterator_cf(cf_handle, prefix);
-
-        iterator
-            .last()
-            .map(|(_, v)| -> Result<_, CompactFiltersError> {
-                let (header, _): (BlockHeader, Uint256) = SerializeDb::deserialize(&v)?;
-
-                Ok(header.block_hash())
-            })
-            .transpose()
-    }
-
-    pub fn apply(
-        &mut self,
-        from: usize,
-        headers: Vec<BlockHeader>,
-    ) -> Result<BlockHash, CompactFiltersError> {
-        let mut batch = WriteBatch::default();
-
-        let read_store = self.store.read().unwrap();
-        let cf_handle = read_store.cf_handle(&self.cf_name).unwrap();
-
-        let (mut last_hash, mut accumulated_work) = read_store
-            .get_pinned_cf(cf_handle, StoreEntry::BlockHeader(Some(from)).get_key())?
-            .map(|result| {
-                let (header, work): (BlockHeader, Uint256) = SerializeDb::deserialize(&result)?;
-                Ok::<_, CompactFiltersError>((header.block_hash(), work))
-            })
-            .transpose()?
-            .ok_or(CompactFiltersError::DataCorruption)?;
-
-        for (index, header) in headers.into_iter().enumerate() {
-            if header.prev_blockhash != last_hash {
-                return Err(CompactFiltersError::InvalidHeaders);
-            }
-
-            last_hash = header.block_hash();
-            accumulated_work = accumulated_work + header.work();
-
-            let height = from + index + 1;
-            batch.put_cf(
-                cf_handle,
-                StoreEntry::BlockHeaderIndex(Some(header.block_hash())).get_key(),
-                (height).to_be_bytes(),
-            );
-            batch.put_cf(
-                cf_handle,
-                StoreEntry::BlockHeader(Some(height)).get_key(),
-                (header, accumulated_work).serialize(),
-            );
-        }
-
-        std::mem::drop(read_store);
-
-        self.store.write().unwrap().write(batch)?;
-        Ok(last_hash)
-    }
-}
-
-impl<T: StoreType> fmt::Debug for ChainStore<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct(&format!("ChainStore<{:?}>", T::default()))
-            .field("cf_name", &self.cf_name)
-            .field("min_height", &self.min_height)
-            .field("network", &self.network)
-            .field("headers_height", &self.get_height())
-            .field("tip_hash", &self.get_tip_hash())
-            .finish()
-    }
-}
-
-pub enum BundleStatus {
-    Init,
-    CfHeaders { cf_headers: Vec<FilterHeader> },
-    CFilters { cf_filters: Vec<Vec<u8>> },
-    Processed { cf_filters: Vec<Vec<u8>> },
-    Tip { cf_filters: Vec<Vec<u8>> },
-    Pruned,
-}
-
-pub struct CfStore {
-    store: Arc<RwLock<DB>>,
-    filter_type: u8,
-}
-
-type BundleEntry = (BundleStatus, FilterHeader);
-
-impl CfStore {
-    pub fn new(
-        headers_store: &ChainStore<Full>,
-        filter_type: u8,
-    ) -> Result<Self, CompactFiltersError> {
-        let cf_store = CfStore {
-            store: Arc::clone(&headers_store.store),
-            filter_type,
-        };
-
-        let genesis = genesis_block(headers_store.network);
-
-        let filter = BlockFilter::new_script_filter(&genesis, |utxo| {
-            Err(bitcoin::util::bip158::Error::UtxoMissing(*utxo))
-        })?;
-        let first_key = StoreEntry::CFilterTable((filter_type, Some(0))).get_key();
-
-        // Add the genesis' filter
-        {
-            let read_store = cf_store.store.read().unwrap();
-            if read_store.get_pinned(&first_key)?.is_none() {
-                read_store.put(
-                    &first_key,
-                    (
-                        BundleStatus::Init,
-                        filter.filter_header(&FilterHeader::from_hash(Hash::all_zeros())),
-                    )
-                        .serialize(),
-                )?;
-            }
-        }
-
-        Ok(cf_store)
-    }
-
-    pub fn get_filter_type(&self) -> u8 {
-        self.filter_type
-    }
-
-    pub fn get_bundles(&self) -> Result<Vec<BundleEntry>, CompactFiltersError> {
-        let read_store = self.store.read().unwrap();
-
-        let prefix = StoreEntry::CFilterTable((self.filter_type, None)).get_key();
-        let iterator = read_store.prefix_iterator(&prefix);
-
-        // FIXME: we have to filter manually because rocksdb sometimes returns stuff that doesn't
-        // have the right prefix
-        iterator
-            .filter(|(k, _)| k.starts_with(&prefix))
-            .map(|(_, data)| BundleEntry::deserialize(&data))
-            .collect::<Result<_, _>>()
-    }
-
-    pub fn get_checkpoints(&self) -> Result<Vec<FilterHeader>, CompactFiltersError> {
-        let read_store = self.store.read().unwrap();
-
-        let prefix = StoreEntry::CFilterTable((self.filter_type, None)).get_key();
-        let iterator = read_store.prefix_iterator(&prefix);
-
-        // FIXME: we have to filter manually because rocksdb sometimes returns stuff that doesn't
-        // have the right prefix
-        iterator
-            .filter(|(k, _)| k.starts_with(&prefix))
-            .skip(1)
-            .map(|(_, data)| Ok::<_, CompactFiltersError>(BundleEntry::deserialize(&data)?.1))
-            .collect::<Result<_, _>>()
-    }
-
-    pub fn replace_checkpoints(
-        &self,
-        checkpoints: Vec<FilterHeader>,
-    ) -> Result<(), CompactFiltersError> {
-        let current_checkpoints = self.get_checkpoints()?;
-
-        let mut equal_bundles = 0;
-        for (index, (our, their)) in current_checkpoints
-            .iter()
-            .zip(checkpoints.iter())
-            .enumerate()
-        {
-            equal_bundles = index;
-
-            if our != their {
-                break;
-            }
-        }
-
-        let read_store = self.store.read().unwrap();
-        let mut batch = WriteBatch::default();
-
-        for (index, filter_hash) in checkpoints.iter().enumerate().skip(equal_bundles) {
-            let key = StoreEntry::CFilterTable((self.filter_type, Some(index + 1))).get_key(); // +1 to skip the genesis' filter
-
-            if let Some((BundleStatus::Tip { .. }, _)) = read_store
-                .get_pinned(&key)?
-                .map(|data| BundleEntry::deserialize(&data))
-                .transpose()?
-            {
-                println!("Keeping bundle #{} as Tip", index);
-            } else {
-                batch.put(&key, (BundleStatus::Init, *filter_hash).serialize());
-            }
-        }
-
-        read_store.write(batch)?;
-
-        Ok(())
-    }
-
-    pub fn advance_to_cf_headers(
-        &self,
-        bundle: usize,
-        checkpoint: FilterHeader,
-        filter_hashes: Vec<FilterHash>,
-    ) -> Result<BundleStatus, CompactFiltersError> {
-        let cf_headers: Vec<FilterHeader> = filter_hashes
-            .into_iter()
-            .scan(checkpoint, |prev_header, filter_hash| {
-                let filter_header = filter_hash.filter_header(prev_header);
-                *prev_header = filter_header;
-
-                Some(filter_header)
-            })
-            .collect();
-
-        let read_store = self.store.read().unwrap();
-
-        let next_key = StoreEntry::CFilterTable((self.filter_type, Some(bundle + 1))).get_key(); // +1 to skip the genesis' filter
-        if let Some((_, next_checkpoint)) = read_store
-            .get_pinned(&next_key)?
-            .map(|data| BundleEntry::deserialize(&data))
-            .transpose()?
-        {
-            // check connection with the next bundle if present
-            if cf_headers.iter().last() != Some(&next_checkpoint) {
-                return Err(CompactFiltersError::InvalidFilterHeader);
-            }
-        }
-
-        let key = StoreEntry::CFilterTable((self.filter_type, Some(bundle))).get_key();
-        let value = (BundleStatus::CfHeaders { cf_headers }, checkpoint);
-
-        read_store.put(key, value.serialize())?;
-
-        Ok(value.0)
-    }
-
-    pub fn advance_to_cf_filters(
-        &self,
-        bundle: usize,
-        checkpoint: FilterHeader,
-        headers: Vec<FilterHeader>,
-        filters: Vec<(usize, Vec<u8>)>,
-    ) -> Result<BundleStatus, CompactFiltersError> {
-        let cf_filters = filters
-            .into_iter()
-            .zip(headers.into_iter())
-            .scan(checkpoint, |prev_header, ((_, filter_content), header)| {
-                let filter = BlockFilter::new(&filter_content);
-                if header != filter.filter_header(prev_header) {
-                    return Some(Err(CompactFiltersError::InvalidFilter));
-                }
-                *prev_header = header;
-
-                Some(Ok::<_, CompactFiltersError>(filter_content))
-            })
-            .collect::<Result<_, _>>()?;
-
-        let key = StoreEntry::CFilterTable((self.filter_type, Some(bundle))).get_key();
-        let value = (BundleStatus::CFilters { cf_filters }, checkpoint);
-
-        let read_store = self.store.read().unwrap();
-        read_store.put(key, value.serialize())?;
-
-        Ok(value.0)
-    }
-
-    pub fn prune_filters(
-        &self,
-        bundle: usize,
-        checkpoint: FilterHeader,
-    ) -> Result<BundleStatus, CompactFiltersError> {
-        let key = StoreEntry::CFilterTable((self.filter_type, Some(bundle))).get_key();
-        let value = (BundleStatus::Pruned, checkpoint);
-
-        let read_store = self.store.read().unwrap();
-        read_store.put(key, value.serialize())?;
-
-        Ok(value.0)
-    }
-
-    pub fn mark_as_tip(
-        &self,
-        bundle: usize,
-        cf_filters: Vec<Vec<u8>>,
-        checkpoint: FilterHeader,
-    ) -> Result<BundleStatus, CompactFiltersError> {
-        let key = StoreEntry::CFilterTable((self.filter_type, Some(bundle))).get_key();
-        let value = (BundleStatus::Tip { cf_filters }, checkpoint);
-
-        let read_store = self.store.read().unwrap();
-        read_store.put(key, value.serialize())?;
-
-        Ok(value.0)
-    }
-}
+// // Bitcoin Dev Kit
+// // Written in 2020 by Alekos Filini <alekos.filini@gmail.com>
+// //
+// // Copyright (c) 2020-2021 Bitcoin Dev Kit Developers
+// //
+// // This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
+// // or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
+// // You may not use this file except in accordance with one or both of these
+// // licenses.
+
+// use std::convert::TryInto;
+// use std::fmt;
+// use std::io::{Read, Write};
+// use std::marker::PhantomData;
+// use std::sync::Arc;
+// use std::sync::RwLock;
+
+// use rand::distributions::Alphanumeric;
+// use rand::{thread_rng, Rng};
+
+// use rocksdb::{Direction, IteratorMode, ReadOptions, WriteBatch, DB};
+
+// use bitcoin::blockdata::constants::genesis_block;
+// use bitcoin::consensus::{deserialize, encode::VarInt, serialize, Decodable, Encodable};
+// use bitcoin::hash_types::{FilterHash, FilterHeader};
+// use bitcoin::hashes::Hash;
+// use bitcoin::util::bip158::BlockFilter;
+// use bitcoin::util::uint::Uint256;
+// use bitcoin::Block;
+// use bitcoin::BlockHash;
+// use bitcoin::BlockHeader;
+// use bitcoin::Network;
+
+// use super::CompactFiltersError;
+
+// pub trait StoreType: Default + fmt::Debug {}
+
+// #[derive(Default, Debug)]
+// pub struct Full;
+// impl StoreType for Full {}
+// #[derive(Default, Debug)]
+// pub struct Snapshot;
+// impl StoreType for Snapshot {}
+
+// pub enum StoreEntry {
+//     BlockHeader(Option<usize>),
+//     Block(Option<usize>),
+//     BlockHeaderIndex(Option<BlockHash>),
+//     CFilterTable((u8, Option<usize>)),
+// }
+
+// impl StoreEntry {
+//     pub fn get_prefix(&self) -> Vec<u8> {
+//         match self {
+//             StoreEntry::BlockHeader(_) => b"z",
+//             StoreEntry::Block(_) => b"x",
+//             StoreEntry::BlockHeaderIndex(_) => b"i",
+//             StoreEntry::CFilterTable(_) => b"t",
+//         }
+//         .to_vec()
+//     }
+
+//     pub fn get_key(&self) -> Vec<u8> {
+//         let mut prefix = self.get_prefix();
+//         match self {
+//             StoreEntry::BlockHeader(Some(height)) => {
+//                 prefix.extend_from_slice(&height.to_be_bytes())
+//             }
+//             StoreEntry::Block(Some(height)) => prefix.extend_from_slice(&height.to_be_bytes()),
+//             StoreEntry::BlockHeaderIndex(Some(hash)) => {
+//                 prefix.extend_from_slice(&hash.into_inner())
+//             }
+//             StoreEntry::CFilterTable((filter_type, bundle_index)) => {
+//                 prefix.push(*filter_type);
+//                 if let Some(bundle_index) = bundle_index {
+//                     prefix.extend_from_slice(&bundle_index.to_be_bytes());
+//                 }
+//             }
+//             _ => {}
+//         }
+
+//         prefix
+//     }
+// }
+
+// pub trait SerializeDb: Sized {
+//     fn serialize(&self) -> Vec<u8>;
+//     fn deserialize(data: &[u8]) -> Result<Self, CompactFiltersError>;
+// }
+
+// impl<T> SerializeDb for T
+// where
+//     T: Encodable + Decodable,
+// {
+//     fn serialize(&self) -> Vec<u8> {
+//         serialize(self)
+//     }
+
+//     fn deserialize(data: &[u8]) -> Result<Self, CompactFiltersError> {
+//         deserialize(data).map_err(|_| CompactFiltersError::DataCorruption)
+//     }
+// }
+
+// impl Encodable for BundleStatus {
+//     fn consensus_encode<W: Write + ?Sized>(&self, e: &mut W) -> Result<usize, std::io::Error> {
+//         let mut written = 0;
+
+//         match self {
+//             BundleStatus::Init => {
+//                 written += 0x00u8.consensus_encode(e)?;
+//             }
+//             BundleStatus::CfHeaders { cf_headers } => {
+//                 written += 0x01u8.consensus_encode(e)?;
+//                 written += VarInt(cf_headers.len() as u64).consensus_encode(e)?;
+//                 for header in cf_headers {
+//                     written += header.consensus_encode(e)?;
+//                 }
+//             }
+//             BundleStatus::CFilters { cf_filters } => {
+//                 written += 0x02u8.consensus_encode(e)?;
+//                 written += VarInt(cf_filters.len() as u64).consensus_encode(e)?;
+//                 for filter in cf_filters {
+//                     written += filter.consensus_encode(e)?;
+//                 }
+//             }
+//             BundleStatus::Processed { cf_filters } => {
+//                 written += 0x03u8.consensus_encode(e)?;
+//                 written += VarInt(cf_filters.len() as u64).consensus_encode(e)?;
+//                 for filter in cf_filters {
+//                     written += filter.consensus_encode(e)?;
+//                 }
+//             }
+//             BundleStatus::Pruned => {
+//                 written += 0x04u8.consensus_encode(e)?;
+//             }
+//             BundleStatus::Tip { cf_filters } => {
+//                 written += 0x05u8.consensus_encode(e)?;
+//                 written += VarInt(cf_filters.len() as u64).consensus_encode(e)?;
+//                 for filter in cf_filters {
+//                     written += filter.consensus_encode(e)?;
+//                 }
+//             }
+//         }
+
+//         Ok(written)
+//     }
+// }
+
+// impl Decodable for BundleStatus {
+//     fn consensus_decode<D: Read + ?Sized>(
+//         d: &mut D,
+//     ) -> Result<Self, bitcoin::consensus::encode::Error> {
+//         let byte_type = u8::consensus_decode(d)?;
+//         match byte_type {
+//             0x00 => Ok(BundleStatus::Init),
+//             0x01 => {
+//                 let num = VarInt::consensus_decode(d)?;
+//                 let num = num.0 as usize;
+
+//                 let mut cf_headers = Vec::with_capacity(num);
+//                 for _ in 0..num {
+//                     cf_headers.push(FilterHeader::consensus_decode(d)?);
+//                 }
+
+//                 Ok(BundleStatus::CfHeaders { cf_headers })
+//             }
+//             0x02 => {
+//                 let num = VarInt::consensus_decode(d)?;
+//                 let num = num.0 as usize;
+
+//                 let mut cf_filters = Vec::with_capacity(num);
+//                 for _ in 0..num {
+//                     cf_filters.push(Vec::<u8>::consensus_decode(d)?);
+//                 }
+
+//                 Ok(BundleStatus::CFilters { cf_filters })
+//             }
+//             0x03 => {
+//                 let num = VarInt::consensus_decode(d)?;
+//                 let num = num.0 as usize;
+
+//                 let mut cf_filters = Vec::with_capacity(num);
+//                 for _ in 0..num {
+//                     cf_filters.push(Vec::<u8>::consensus_decode(d)?);
+//                 }
+
+//                 Ok(BundleStatus::Processed { cf_filters })
+//             }
+//             0x04 => Ok(BundleStatus::Pruned),
+//             0x05 => {
+//                 let num = VarInt::consensus_decode(d)?;
+//                 let num = num.0 as usize;
+
+//                 let mut cf_filters = Vec::with_capacity(num);
+//                 for _ in 0..num {
+//                     cf_filters.push(Vec::<u8>::consensus_decode(d)?);
+//                 }
+
+//                 Ok(BundleStatus::Tip { cf_filters })
+//             }
+//             _ => Err(bitcoin::consensus::encode::Error::ParseFailed(
+//                 "Invalid byte type",
+//             )),
+//         }
+//     }
+// }
+
+// pub struct ChainStore<T: StoreType> {
+//     store: Arc<RwLock<DB>>,
+//     cf_name: String,
+//     min_height: usize,
+//     network: Network,
+//     phantom: PhantomData<T>,
+// }
+
+// impl ChainStore<Full> {
+//     pub fn new(store: DB, network: Network) -> Result<Self, CompactFiltersError> {
+//         let genesis = genesis_block(network);
+
+//         let cf_name = "default".to_string();
+//         let cf_handle = store.cf_handle(&cf_name).unwrap();
+
+//         let genesis_key = StoreEntry::BlockHeader(Some(0)).get_key();
+
+//         if store.get_pinned_cf(cf_handle, &genesis_key)?.is_none() {
+//             let mut batch = WriteBatch::default();
+//             batch.put_cf(
+//                 cf_handle,
+//                 genesis_key,
+//                 (genesis.header, genesis.header.work()).serialize(),
+//             );
+//             batch.put_cf(
+//                 cf_handle,
+//                 StoreEntry::BlockHeaderIndex(Some(genesis.block_hash())).get_key(),
+//                 0usize.to_be_bytes(),
+//             );
+//             store.write(batch)?;
+//         }
+
+//         Ok(ChainStore {
+//             store: Arc::new(RwLock::new(store)),
+//             cf_name,
+//             min_height: 0,
+//             network,
+//             phantom: PhantomData,
+//         })
+//     }
+
+//     pub fn get_locators(&self) -> Result<Vec<(BlockHash, usize)>, CompactFiltersError> {
+//         let mut step = 1;
+//         let mut index = self.get_height()?;
+//         let mut answer = Vec::new();
+
+//         let store_read = self.store.read().unwrap();
+//         let cf_handle = store_read.cf_handle(&self.cf_name).unwrap();
+
+//         loop {
+//             if answer.len() > 10 {
+//                 step *= 2;
+//             }
+
+//             let (header, _): (BlockHeader, Uint256) = SerializeDb::deserialize(
+//                 &store_read
+//                     .get_pinned_cf(cf_handle, StoreEntry::BlockHeader(Some(index)).get_key())?
+//                     .unwrap(),
+//             )?;
+//             answer.push((header.block_hash(), index));
+
+//             if let Some(new_index) = index.checked_sub(step) {
+//                 index = new_index;
+//             } else {
+//                 break;
+//             }
+//         }
+
+//         Ok(answer)
+//     }
+
+//     pub fn start_snapshot(&self, from: usize) -> Result<ChainStore<Snapshot>, CompactFiltersError> {
+//         let new_cf_name: String = thread_rng()
+//             .sample_iter(&Alphanumeric)
+//             .map(|byte| byte as char)
+//             .take(16)
+//             .collect();
+//         let new_cf_name = format!("_headers:{}", new_cf_name);
+
+//         let mut write_store = self.store.write().unwrap();
+
+//         write_store.create_cf(&new_cf_name, &Default::default())?;
+
+//         let cf_handle = write_store.cf_handle(&self.cf_name).unwrap();
+//         let new_cf_handle = write_store.cf_handle(&new_cf_name).unwrap();
+
+//         let (header, work): (BlockHeader, Uint256) = SerializeDb::deserialize(
+//             &write_store
+//                 .get_pinned_cf(cf_handle, StoreEntry::BlockHeader(Some(from)).get_key())?
+//                 .ok_or(CompactFiltersError::DataCorruption)?,
+//         )?;
+
+//         let mut batch = WriteBatch::default();
+//         batch.put_cf(
+//             new_cf_handle,
+//             StoreEntry::BlockHeaderIndex(Some(header.block_hash())).get_key(),
+//             from.to_be_bytes(),
+//         );
+//         batch.put_cf(
+//             new_cf_handle,
+//             StoreEntry::BlockHeader(Some(from)).get_key(),
+//             (header, work).serialize(),
+//         );
+//         write_store.write(batch)?;
+
+//         let store = Arc::clone(&self.store);
+//         Ok(ChainStore {
+//             store,
+//             cf_name: new_cf_name,
+//             min_height: from,
+//             network: self.network,
+//             phantom: PhantomData,
+//         })
+//     }
+
+//     pub fn recover_snapshot(&self, cf_name: &str) -> Result<(), CompactFiltersError> {
+//         let mut write_store = self.store.write().unwrap();
+//         let snapshot_cf_handle = write_store.cf_handle(cf_name).unwrap();
+
+//         let prefix = StoreEntry::BlockHeader(None).get_key();
+//         let mut iterator = write_store.prefix_iterator_cf(snapshot_cf_handle, prefix);
+
+//         let min_height = match iterator
+//             .next()
+//             .and_then(|(k, _)| k[1..].try_into().ok())
+//             .map(usize::from_be_bytes)
+//         {
+//             None => {
+//                 std::mem::drop(iterator);
+//                 write_store.drop_cf(cf_name).ok();
+
+//                 return Ok(());
+//             }
+//             Some(x) => x,
+//         };
+//         std::mem::drop(iterator);
+//         std::mem::drop(write_store);
+
+//         let snapshot = ChainStore {
+//             store: Arc::clone(&self.store),
+//             cf_name: cf_name.into(),
+//             min_height,
+//             network: self.network,
+//             phantom: PhantomData,
+//         };
+//         if snapshot.work()? > self.work()? {
+//             self.apply_snapshot(snapshot)?;
+//         }
+
+//         Ok(())
+//     }
+
+//     pub fn apply_snapshot(
+//         &self,
+//         snaphost: ChainStore<Snapshot>,
+//     ) -> Result<(), CompactFiltersError> {
+//         let mut batch = WriteBatch::default();
+
+//         let read_store = self.store.read().unwrap();
+//         let cf_handle = read_store.cf_handle(&self.cf_name).unwrap();
+//         let snapshot_cf_handle = read_store.cf_handle(&snaphost.cf_name).unwrap();
+
+//         let from_key = StoreEntry::BlockHeader(Some(snaphost.min_height)).get_key();
+//         let to_key = StoreEntry::BlockHeader(Some(usize::MAX)).get_key();
+
+//         let mut opts = ReadOptions::default();
+//         opts.set_iterate_upper_bound(to_key.clone());
+
+//         log::debug!("Removing items");
+//         batch.delete_range_cf(cf_handle, &from_key, &to_key);
+//         for (_, v) in read_store.iterator_cf_opt(
+//             cf_handle,
+//             opts,
+//             IteratorMode::From(&from_key, Direction::Forward),
+//         ) {
+//             let (header, _): (BlockHeader, Uint256) = SerializeDb::deserialize(&v)?;
+
+//             batch.delete_cf(
+//                 cf_handle,
+//                 StoreEntry::BlockHeaderIndex(Some(header.block_hash())).get_key(),
+//             );
+//         }
+
+//         // Delete full blocks overridden by snapshot
+//         let from_key = StoreEntry::Block(Some(snaphost.min_height)).get_key();
+//         let to_key = StoreEntry::Block(Some(usize::MAX)).get_key();
+//         batch.delete_range(&from_key, &to_key);
+
+//         log::debug!("Copying over new items");
+//         for (k, v) in read_store.iterator_cf(snapshot_cf_handle, IteratorMode::Start) {
+//             batch.put_cf(cf_handle, k, v);
+//         }
+
+//         read_store.write(batch)?;
+//         std::mem::drop(read_store);
+
+//         self.store.write().unwrap().drop_cf(&snaphost.cf_name)?;
+
+//         Ok(())
+//     }
+
+//     pub fn get_height_for(
+//         &self,
+//         block_hash: &BlockHash,
+//     ) -> Result<Option<usize>, CompactFiltersError> {
+//         let read_store = self.store.read().unwrap();
+//         let cf_handle = read_store.cf_handle(&self.cf_name).unwrap();
+
+//         let key = StoreEntry::BlockHeaderIndex(Some(*block_hash)).get_key();
+//         let data = read_store.get_pinned_cf(cf_handle, key)?;
+//         data.map(|data| {
+//             Ok::<_, CompactFiltersError>(usize::from_be_bytes(
+//                 data.as_ref()
+//                     .try_into()
+//                     .map_err(|_| CompactFiltersError::DataCorruption)?,
+//             ))
+//         })
+//         .transpose()
+//     }
+
+//     pub fn get_block_hash(&self, height: usize) -> Result<Option<BlockHash>, CompactFiltersError> {
+//         let read_store = self.store.read().unwrap();
+//         let cf_handle = read_store.cf_handle(&self.cf_name).unwrap();
+
+//         let key = StoreEntry::BlockHeader(Some(height)).get_key();
+//         let data = read_store.get_pinned_cf(cf_handle, key)?;
+//         data.map(|data| {
+//             let (header, _): (BlockHeader, Uint256) =
+//                 deserialize(&data).map_err(|_| CompactFiltersError::DataCorruption)?;
+//             Ok::<_, CompactFiltersError>(header.block_hash())
+//         })
+//         .transpose()
+//     }
+
+//     pub fn save_full_block(&self, block: &Block, height: usize) -> Result<(), CompactFiltersError> {
+//         let key = StoreEntry::Block(Some(height)).get_key();
+//         self.store.read().unwrap().put(key, block.serialize())?;
+
+//         Ok(())
+//     }
+
+//     pub fn get_full_block(&self, height: usize) -> Result<Option<Block>, CompactFiltersError> {
+//         let read_store = self.store.read().unwrap();
+
+//         let key = StoreEntry::Block(Some(height)).get_key();
+//         let opt_block = read_store.get_pinned(key)?;
+
+//         opt_block
+//             .map(|data| deserialize(&data))
+//             .transpose()
+//             .map_err(|_| CompactFiltersError::DataCorruption)
+//     }
+
+//     pub fn delete_blocks_until(&self, height: usize) -> Result<(), CompactFiltersError> {
+//         let from_key = StoreEntry::Block(Some(0)).get_key();
+//         let to_key = StoreEntry::Block(Some(height)).get_key();
+
+//         let mut batch = WriteBatch::default();
+//         batch.delete_range(&from_key, &to_key);
+
+//         self.store.read().unwrap().write(batch)?;
+
+//         Ok(())
+//     }
+
+//     pub fn iter_full_blocks(&self) -> Result<Vec<(usize, Block)>, CompactFiltersError> {
+//         let read_store = self.store.read().unwrap();
+
+//         let prefix = StoreEntry::Block(None).get_key();
+
+//         let iterator = read_store.prefix_iterator(&prefix);
+//         // FIXME: we have to filter manually because rocksdb sometimes returns stuff that doesn't
+//         // have the right prefix
+//         iterator
+//             .filter(|(k, _)| k.starts_with(&prefix))
+//             .map(|(k, v)| {
+//                 let height: usize = usize::from_be_bytes(
+//                     k[1..]
+//                         .try_into()
+//                         .map_err(|_| CompactFiltersError::DataCorruption)?,
+//                 );
+//                 let block = SerializeDb::deserialize(&v)?;
+
+//                 Ok((height, block))
+//             })
+//             .collect::<Result<_, _>>()
+//     }
+// }
+
+// impl<T: StoreType> ChainStore<T> {
+//     pub fn work(&self) -> Result<Uint256, CompactFiltersError> {
+//         let read_store = self.store.read().unwrap();
+//         let cf_handle = read_store.cf_handle(&self.cf_name).unwrap();
+
+//         let prefix = StoreEntry::BlockHeader(None).get_key();
+//         let iterator = read_store.prefix_iterator_cf(cf_handle, prefix);
+
+//         Ok(iterator
+//             .last()
+//             .map(|(_, v)| -> Result<_, CompactFiltersError> {
+//                 let (_, work): (BlockHeader, Uint256) = SerializeDb::deserialize(&v)?;
+
+//                 Ok(work)
+//             })
+//             .transpose()?
+//             .unwrap_or_default())
+//     }
+
+//     pub fn get_height(&self) -> Result<usize, CompactFiltersError> {
+//         let read_store = self.store.read().unwrap();
+//         let cf_handle = read_store.cf_handle(&self.cf_name).unwrap();
+
+//         let prefix = StoreEntry::BlockHeader(None).get_key();
+//         let iterator = read_store.prefix_iterator_cf(cf_handle, prefix);
+
+//         Ok(iterator
+//             .last()
+//             .map(|(k, _)| -> Result<_, CompactFiltersError> {
+//                 let height = usize::from_be_bytes(
+//                     k[1..]
+//                         .try_into()
+//                         .map_err(|_| CompactFiltersError::DataCorruption)?,
+//                 );
+
+//                 Ok(height)
+//             })
+//             .transpose()?
+//             .unwrap_or_default())
+//     }
+
+//     pub fn get_tip_hash(&self) -> Result<Option<BlockHash>, CompactFiltersError> {
+//         let read_store = self.store.read().unwrap();
+//         let cf_handle = read_store.cf_handle(&self.cf_name).unwrap();
+
+//         let prefix = StoreEntry::BlockHeader(None).get_key();
+//         let iterator = read_store.prefix_iterator_cf(cf_handle, prefix);
+
+//         iterator
+//             .last()
+//             .map(|(_, v)| -> Result<_, CompactFiltersError> {
+//                 let (header, _): (BlockHeader, Uint256) = SerializeDb::deserialize(&v)?;
+
+//                 Ok(header.block_hash())
+//             })
+//             .transpose()
+//     }
+
+//     pub fn apply(
+//         &mut self,
+//         from: usize,
+//         headers: Vec<BlockHeader>,
+//     ) -> Result<BlockHash, CompactFiltersError> {
+//         let mut batch = WriteBatch::default();
+
+//         let read_store = self.store.read().unwrap();
+//         let cf_handle = read_store.cf_handle(&self.cf_name).unwrap();
+
+//         let (mut last_hash, mut accumulated_work) = read_store
+//             .get_pinned_cf(cf_handle, StoreEntry::BlockHeader(Some(from)).get_key())?
+//             .map(|result| {
+//                 let (header, work): (BlockHeader, Uint256) = SerializeDb::deserialize(&result)?;
+//                 Ok::<_, CompactFiltersError>((header.block_hash(), work))
+//             })
+//             .transpose()?
+//             .ok_or(CompactFiltersError::DataCorruption)?;
+
+//         for (index, header) in headers.into_iter().enumerate() {
+//             if header.prev_blockhash != last_hash {
+//                 return Err(CompactFiltersError::InvalidHeaders);
+//             }
+
+//             last_hash = header.block_hash();
+//             accumulated_work = accumulated_work + header.work();
+
+//             let height = from + index + 1;
+//             batch.put_cf(
+//                 cf_handle,
+//                 StoreEntry::BlockHeaderIndex(Some(header.block_hash())).get_key(),
+//                 (height).to_be_bytes(),
+//             );
+//             batch.put_cf(
+//                 cf_handle,
+//                 StoreEntry::BlockHeader(Some(height)).get_key(),
+//                 (header, accumulated_work).serialize(),
+//             );
+//         }
+
+//         std::mem::drop(read_store);
+
+//         self.store.write().unwrap().write(batch)?;
+//         Ok(last_hash)
+//     }
+// }
+
+// impl<T: StoreType> fmt::Debug for ChainStore<T> {
+//     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+//         f.debug_struct(&format!("ChainStore<{:?}>", T::default()))
+//             .field("cf_name", &self.cf_name)
+//             .field("min_height", &self.min_height)
+//             .field("network", &self.network)
+//             .field("headers_height", &self.get_height())
+//             .field("tip_hash", &self.get_tip_hash())
+//             .finish()
+//     }
+// }
+
+// pub enum BundleStatus {
+//     Init,
+//     CfHeaders { cf_headers: Vec<FilterHeader> },
+//     CFilters { cf_filters: Vec<Vec<u8>> },
+//     Processed { cf_filters: Vec<Vec<u8>> },
+//     Tip { cf_filters: Vec<Vec<u8>> },
+//     Pruned,
+// }
+
+// pub struct CfStore {
+//     store: Arc<RwLock<DB>>,
+//     filter_type: u8,
+// }
+
+// type BundleEntry = (BundleStatus, FilterHeader);
+
+// impl CfStore {
+//     pub fn new(
+//         headers_store: &ChainStore<Full>,
+//         filter_type: u8,
+//     ) -> Result<Self, CompactFiltersError> {
+//         let cf_store = CfStore {
+//             store: Arc::clone(&headers_store.store),
+//             filter_type,
+//         };
+
+//         let genesis = genesis_block(headers_store.network);
+
+//         let filter = BlockFilter::new_script_filter(&genesis, |utxo| {
+//             Err(bitcoin::util::bip158::Error::UtxoMissing(*utxo))
+//         })?;
+//         let first_key = StoreEntry::CFilterTable((filter_type, Some(0))).get_key();
+
+//         // Add the genesis' filter
+//         {
+//             let read_store = cf_store.store.read().unwrap();
+//             if read_store.get_pinned(&first_key)?.is_none() {
+//                 read_store.put(
+//                     &first_key,
+//                     (
+//                         BundleStatus::Init,
+//                         filter.filter_header(&FilterHeader::from_hash(Hash::all_zeros())),
+//                     )
+//                         .serialize(),
+//                 )?;
+//             }
+//         }
+
+//         Ok(cf_store)
+//     }
+
+//     pub fn get_filter_type(&self) -> u8 {
+//         self.filter_type
+//     }
+
+//     pub fn get_bundles(&self) -> Result<Vec<BundleEntry>, CompactFiltersError> {
+//         let read_store = self.store.read().unwrap();
+
+//         let prefix = StoreEntry::CFilterTable((self.filter_type, None)).get_key();
+//         let iterator = read_store.prefix_iterator(&prefix);
+
+//         // FIXME: we have to filter manually because rocksdb sometimes returns stuff that doesn't
+//         // have the right prefix
+//         iterator
+//             .filter(|(k, _)| k.starts_with(&prefix))
+//             .map(|(_, data)| BundleEntry::deserialize(&data))
+//             .collect::<Result<_, _>>()
+//     }
+
+//     pub fn get_checkpoints(&self) -> Result<Vec<FilterHeader>, CompactFiltersError> {
+//         let read_store = self.store.read().unwrap();
+
+//         let prefix = StoreEntry::CFilterTable((self.filter_type, None)).get_key();
+//         let iterator = read_store.prefix_iterator(&prefix);
+
+//         // FIXME: we have to filter manually because rocksdb sometimes returns stuff that doesn't
+//         // have the right prefix
+//         iterator
+//             .filter(|(k, _)| k.starts_with(&prefix))
+//             .skip(1)
+//             .map(|(_, data)| Ok::<_, CompactFiltersError>(BundleEntry::deserialize(&data)?.1))
+//             .collect::<Result<_, _>>()
+//     }
+
+//     pub fn replace_checkpoints(
+//         &self,
+//         checkpoints: Vec<FilterHeader>,
+//     ) -> Result<(), CompactFiltersError> {
+//         let current_checkpoints = self.get_checkpoints()?;
+
+//         let mut equal_bundles = 0;
+//         for (index, (our, their)) in current_checkpoints
+//             .iter()
+//             .zip(checkpoints.iter())
+//             .enumerate()
+//         {
+//             equal_bundles = index;
+
+//             if our != their {
+//                 break;
+//             }
+//         }
+
+//         let read_store = self.store.read().unwrap();
+//         let mut batch = WriteBatch::default();
+
+//         for (index, filter_hash) in checkpoints.iter().enumerate().skip(equal_bundles) {
+//             let key = StoreEntry::CFilterTable((self.filter_type, Some(index + 1))).get_key(); // +1 to skip the genesis' filter
+
+//             if let Some((BundleStatus::Tip { .. }, _)) = read_store
+//                 .get_pinned(&key)?
+//                 .map(|data| BundleEntry::deserialize(&data))
+//                 .transpose()?
+//             {
+//                 println!("Keeping bundle #{} as Tip", index);
+//             } else {
+//                 batch.put(&key, (BundleStatus::Init, *filter_hash).serialize());
+//             }
+//         }
+
+//         read_store.write(batch)?;
+
+//         Ok(())
+//     }
+
+//     pub fn advance_to_cf_headers(
+//         &self,
+//         bundle: usize,
+//         checkpoint: FilterHeader,
+//         filter_hashes: Vec<FilterHash>,
+//     ) -> Result<BundleStatus, CompactFiltersError> {
+//         let cf_headers: Vec<FilterHeader> = filter_hashes
+//             .into_iter()
+//             .scan(checkpoint, |prev_header, filter_hash| {
+//                 let filter_header = filter_hash.filter_header(prev_header);
+//                 *prev_header = filter_header;
+
+//                 Some(filter_header)
+//             })
+//             .collect();
+
+//         let read_store = self.store.read().unwrap();
+
+//         let next_key = StoreEntry::CFilterTable((self.filter_type, Some(bundle + 1))).get_key(); // +1 to skip the genesis' filter
+//         if let Some((_, next_checkpoint)) = read_store
+//             .get_pinned(&next_key)?
+//             .map(|data| BundleEntry::deserialize(&data))
+//             .transpose()?
+//         {
+//             // check connection with the next bundle if present
+//             if cf_headers.iter().last() != Some(&next_checkpoint) {
+//                 return Err(CompactFiltersError::InvalidFilterHeader);
+//             }
+//         }
+
+//         let key = StoreEntry::CFilterTable((self.filter_type, Some(bundle))).get_key();
+//         let value = (BundleStatus::CfHeaders { cf_headers }, checkpoint);
+
+//         read_store.put(key, value.serialize())?;
+
+//         Ok(value.0)
+//     }
+
+//     pub fn advance_to_cf_filters(
+//         &self,
+//         bundle: usize,
+//         checkpoint: FilterHeader,
+//         headers: Vec<FilterHeader>,
+//         filters: Vec<(usize, Vec<u8>)>,
+//     ) -> Result<BundleStatus, CompactFiltersError> {
+//         let cf_filters = filters
+//             .into_iter()
+//             .zip(headers.into_iter())
+//             .scan(checkpoint, |prev_header, ((_, filter_content), header)| {
+//                 let filter = BlockFilter::new(&filter_content);
+//                 if header != filter.filter_header(prev_header) {
+//                     return Some(Err(CompactFiltersError::InvalidFilter));
+//                 }
+//                 *prev_header = header;
+
+//                 Some(Ok::<_, CompactFiltersError>(filter_content))
+//             })
+//             .collect::<Result<_, _>>()?;
+
+//         let key = StoreEntry::CFilterTable((self.filter_type, Some(bundle))).get_key();
+//         let value = (BundleStatus::CFilters { cf_filters }, checkpoint);
+
+//         let read_store = self.store.read().unwrap();
+//         read_store.put(key, value.serialize())?;
+
+//         Ok(value.0)
+//     }
+
+//     pub fn prune_filters(
+//         &self,
+//         bundle: usize,
+//         checkpoint: FilterHeader,
+//     ) -> Result<BundleStatus, CompactFiltersError> {
+//         let key = StoreEntry::CFilterTable((self.filter_type, Some(bundle))).get_key();
+//         let value = (BundleStatus::Pruned, checkpoint);
+
+//         let read_store = self.store.read().unwrap();
+//         read_store.put(key, value.serialize())?;
+
+//         Ok(value.0)
+//     }
+
+//     pub fn mark_as_tip(
+//         &self,
+//         bundle: usize,
+//         cf_filters: Vec<Vec<u8>>,
+//         checkpoint: FilterHeader,
+//     ) -> Result<BundleStatus, CompactFiltersError> {
+//         let key = StoreEntry::CFilterTable((self.filter_type, Some(bundle))).get_key();
+//         let value = (BundleStatus::Tip { cf_filters }, checkpoint);
+
+//         let read_store = self.store.read().unwrap();
+//         read_store.put(key, value.serialize())?;
+
+//         Ok(value.0)
+//     }
+// }
diff --git a/src/blockchain/compact_filters/sync.rs b/src/blockchain/compact_filters/sync.rs
index ba4e00456..e63d940b9 100644
--- a/src/blockchain/compact_filters/sync.rs
+++ b/src/blockchain/compact_filters/sync.rs
@@ -1,297 +1,297 @@
-// Bitcoin Dev Kit
-// Written in 2020 by Alekos Filini <alekos.filini@gmail.com>
-//
-// Copyright (c) 2020-2021 Bitcoin Dev Kit Developers
-//
-// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
-// or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
-// You may not use this file except in accordance with one or both of these
-// licenses.
-
-use std::collections::{BTreeMap, HashMap, VecDeque};
-use std::sync::{Arc, Mutex};
-use std::time::Duration;
-
-use bitcoin::hash_types::{BlockHash, FilterHeader};
-use bitcoin::hashes::Hash;
-use bitcoin::network::message::NetworkMessage;
-use bitcoin::network::message_blockdata::GetHeadersMessage;
-use bitcoin::util::bip158::BlockFilter;
-
-use super::peer::*;
-use super::store::*;
-use super::CompactFiltersError;
-use crate::error::Error;
-
-pub(crate) const BURIED_CONFIRMATIONS: usize = 100;
-
-pub struct CfSync {
-    headers_store: Arc<ChainStore<Full>>,
-    cf_store: Arc<CfStore>,
-    skip_blocks: usize,
-    bundles: Mutex<VecDeque<(BundleStatus, FilterHeader, usize)>>,
-}
-
-impl CfSync {
-    pub fn new(
-        headers_store: Arc<ChainStore<Full>>,
-        skip_blocks: usize,
-        filter_type: u8,
-    ) -> Result<Self, CompactFiltersError> {
-        let cf_store = Arc::new(CfStore::new(&headers_store, filter_type)?);
-
-        Ok(CfSync {
-            headers_store,
-            cf_store,
-            skip_blocks,
-            bundles: Mutex::new(VecDeque::new()),
-        })
-    }
-
-    pub fn pruned_bundles(&self) -> Result<usize, CompactFiltersError> {
-        Ok(self
-            .cf_store
-            .get_bundles()?
-            .into_iter()
-            .skip(self.skip_blocks / 1000)
-            .fold(0, |acc, (status, _)| match status {
-                BundleStatus::Pruned => acc + 1,
-                _ => acc,
-            }))
-    }
-
-    pub fn prepare_sync(&self, peer: Arc<Peer>) -> Result<(), CompactFiltersError> {
-        let mut bundles_lock = self.bundles.lock().unwrap();
-
-        let resp = peer.get_cf_checkpt(
-            self.cf_store.get_filter_type(),
-            self.headers_store.get_tip_hash()?.unwrap(),
-        )?;
-        self.cf_store.replace_checkpoints(resp.filter_headers)?;
-
-        bundles_lock.clear();
-        for (index, (status, checkpoint)) in self.cf_store.get_bundles()?.into_iter().enumerate() {
-            bundles_lock.push_back((status, checkpoint, index));
-        }
-
-        Ok(())
-    }
-
-    pub fn capture_thread_for_sync<F, Q>(
-        &self,
-        peer: Arc<Peer>,
-        process: F,
-        completed_bundle: Q,
-    ) -> Result<(), CompactFiltersError>
-    where
-        F: Fn(&BlockHash, &BlockFilter) -> Result<bool, CompactFiltersError>,
-        Q: Fn(usize) -> Result<(), Error>,
-    {
-        let current_height = self.headers_store.get_height()?; // TODO: we should update it in case headers_store is also updated
-
-        loop {
-            let (mut status, checkpoint, index) = match self.bundles.lock().unwrap().pop_front() {
-                None => break,
-                Some(x) => x,
-            };
-
-            log::debug!(
-                "Processing bundle #{} - height {} to {}",
-                index,
-                index * 1000 + 1,
-                (index + 1) * 1000
-            );
-
-            let process_received_filters =
-                |expected_filters| -> Result<BTreeMap<usize, Vec<u8>>, CompactFiltersError> {
-                    let mut filters_map = BTreeMap::new();
-                    for _ in 0..expected_filters {
-                        let filter = peer.pop_cf_filter_resp()?;
-                        if filter.filter_type != self.cf_store.get_filter_type() {
-                            return Err(CompactFiltersError::InvalidResponse);
-                        }
-
-                        match self.headers_store.get_height_for(&filter.block_hash)? {
-                            Some(height) => filters_map.insert(height, filter.filter),
-                            None => return Err(CompactFiltersError::InvalidFilter),
-                        };
-                    }
-
-                    Ok(filters_map)
-                };
-
-            let start_height = index * 1000 + 1;
-            let mut already_processed = 0;
-
-            if start_height < self.skip_blocks {
-                status = self.cf_store.prune_filters(index, checkpoint)?;
-            }
-
-            let stop_height = std::cmp::min(current_height, start_height + 999);
-            let stop_hash = self.headers_store.get_block_hash(stop_height)?.unwrap();
-
-            if let BundleStatus::Init = status {
-                log::trace!("status: Init");
-
-                let resp = peer.get_cf_headers(0x00, start_height as u32, stop_hash)?;
-
-                assert_eq!(resp.previous_filter_header, checkpoint);
-                status =
-                    self.cf_store
-                        .advance_to_cf_headers(index, checkpoint, resp.filter_hashes)?;
-            }
-            if let BundleStatus::Tip { cf_filters } = status {
-                log::trace!("status: Tip (beginning) ");
-
-                already_processed = cf_filters.len();
-                let headers_resp = peer.get_cf_headers(0x00, start_height as u32, stop_hash)?;
-
-                let cf_headers = match self.cf_store.advance_to_cf_headers(
-                    index,
-                    checkpoint,
-                    headers_resp.filter_hashes,
-                )? {
-                    BundleStatus::CfHeaders { cf_headers } => cf_headers,
-                    _ => return Err(CompactFiltersError::InvalidResponse),
-                };
-
-                peer.get_cf_filters(
-                    self.cf_store.get_filter_type(),
-                    (start_height + cf_filters.len()) as u32,
-                    stop_hash,
-                )?;
-                let expected_filters = stop_height - start_height + 1 - cf_filters.len();
-                let filters_map = process_received_filters(expected_filters)?;
-                let filters = cf_filters
-                    .into_iter()
-                    .enumerate()
-                    .chain(filters_map.into_iter())
-                    .collect();
-                status = self
-                    .cf_store
-                    .advance_to_cf_filters(index, checkpoint, cf_headers, filters)?;
-            }
-            if let BundleStatus::CfHeaders { cf_headers } = status {
-                log::trace!("status: CFHeaders");
-
-                peer.get_cf_filters(
-                    self.cf_store.get_filter_type(),
-                    start_height as u32,
-                    stop_hash,
-                )?;
-                let expected_filters = stop_height - start_height + 1;
-                let filters_map = process_received_filters(expected_filters)?;
-                status = self.cf_store.advance_to_cf_filters(
-                    index,
-                    checkpoint,
-                    cf_headers,
-                    filters_map.into_iter().collect(),
-                )?;
-            }
-            if let BundleStatus::CFilters { cf_filters } = status {
-                log::trace!("status: CFilters");
-
-                let last_sync_buried_height =
-                    (start_height + already_processed).saturating_sub(BURIED_CONFIRMATIONS);
-
-                for (filter_index, filter) in cf_filters.iter().enumerate() {
-                    let height = filter_index + start_height;
-
-                    // do not download blocks that were already "buried" since the last sync
-                    if height < last_sync_buried_height {
-                        continue;
-                    }
-
-                    let block_hash = self.headers_store.get_block_hash(height)?.unwrap();
-
-                    // TODO: also download random blocks?
-                    if process(&block_hash, &BlockFilter::new(filter))? {
-                        log::debug!("Downloading block {}", block_hash);
-
-                        let block = peer
-                            .get_block(block_hash)?
-                            .ok_or(CompactFiltersError::MissingBlock)?;
-                        self.headers_store.save_full_block(&block, height)?;
-                    }
-                }
-
-                status = BundleStatus::Processed { cf_filters };
-            }
-            if let BundleStatus::Processed { cf_filters } = status {
-                log::trace!("status: Processed");
-
-                if current_height - stop_height > 1000 {
-                    status = self.cf_store.prune_filters(index, checkpoint)?;
-                } else {
-                    status = self.cf_store.mark_as_tip(index, cf_filters, checkpoint)?;
-                }
-
-                completed_bundle(index)?;
-            }
-            if let BundleStatus::Pruned = status {
-                log::trace!("status: Pruned");
-            }
-            if let BundleStatus::Tip { .. } = status {
-                log::trace!("status: Tip");
-            }
-        }
-
-        Ok(())
-    }
-}
-
-pub fn sync_headers<F>(
-    peer: Arc<Peer>,
-    store: Arc<ChainStore<Full>>,
-    sync_fn: F,
-) -> Result<Option<ChainStore<Snapshot>>, CompactFiltersError>
-where
-    F: Fn(usize) -> Result<(), Error>,
-{
-    let locators = store.get_locators()?;
-    let locators_vec = locators.iter().map(|(hash, _)| hash).cloned().collect();
-    let locators_map: HashMap<_, _> = locators.into_iter().collect();
-
-    peer.send(NetworkMessage::GetHeaders(GetHeadersMessage::new(
-        locators_vec,
-        Hash::all_zeros(),
-    )))?;
-    let (mut snapshot, mut last_hash) = if let NetworkMessage::Headers(headers) = peer
-        .recv("headers", Some(Duration::from_secs(TIMEOUT_SECS)))?
-        .ok_or(CompactFiltersError::Timeout)?
-    {
-        if headers.is_empty() {
-            return Ok(None);
-        }
-
-        match locators_map.get(&headers[0].prev_blockhash) {
-            None => return Err(CompactFiltersError::InvalidHeaders),
-            Some(from) => (store.start_snapshot(*from)?, headers[0].prev_blockhash),
-        }
-    } else {
-        return Err(CompactFiltersError::InvalidResponse);
-    };
-
-    let mut sync_height = store.get_height()?;
-    while sync_height < peer.get_version().start_height as usize {
-        peer.send(NetworkMessage::GetHeaders(GetHeadersMessage::new(
-            vec![last_hash],
-            Hash::all_zeros(),
-        )))?;
-        if let NetworkMessage::Headers(headers) = peer
-            .recv("headers", Some(Duration::from_secs(TIMEOUT_SECS)))?
-            .ok_or(CompactFiltersError::Timeout)?
-        {
-            let batch_len = headers.len();
-            last_hash = snapshot.apply(sync_height, headers)?;
-
-            sync_height += batch_len;
-            sync_fn(sync_height)?;
-        } else {
-            return Err(CompactFiltersError::InvalidResponse);
-        }
-    }
-
-    Ok(Some(snapshot))
-}
+// // // Bitcoin Dev Kit
+// // // Written in 2020 by Alekos Filini <alekos.filini@gmail.com>
+// // //
+// // // Copyright (c) 2020-2021 Bitcoin Dev Kit Developers
+// // //
+// // // This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
+// // // or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// // // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
+// // // You may not use this file except in accordance with one or both of these
+// // // licenses.
+
+// // use std::collections::{BTreeMap, HashMap, VecDeque};
+// // use std::sync::{Arc, Mutex};
+// // use std::time::Duration;
+
+// use bitcoin::hash_types::{BlockHash, FilterHeader};
+// use bitcoin::hashes::Hash;
+// use bitcoin::network::message::NetworkMessage;
+// use bitcoin::network::message_blockdata::GetHeadersMessage;
+// use bitcoin::util::bip158::BlockFilter;
+
+// // use super::peer::*;
+// // use super::store::*;
+// // use super::CompactFiltersError;
+// // use crate::error::Error;
+
+// // pub(crate) const BURIED_CONFIRMATIONS: usize = 100;
+
+// // pub struct CfSync {
+// //     headers_store: Arc<ChainStore<Full>>,
+// //     cf_store: Arc<CfStore>,
+// //     skip_blocks: usize,
+// //     bundles: Mutex<VecDeque<(BundleStatus, FilterHeader, usize)>>,
+// // }
+
+// // impl CfSync {
+// //     pub fn new(
+// //         headers_store: Arc<ChainStore<Full>>,
+// //         skip_blocks: usize,
+// //         filter_type: u8,
+// //     ) -> Result<Self, CompactFiltersError> {
+// //         let cf_store = Arc::new(CfStore::new(&headers_store, filter_type)?);
+
+// //         Ok(CfSync {
+// //             headers_store,
+// //             cf_store,
+// //             skip_blocks,
+// //             bundles: Mutex::new(VecDeque::new()),
+// //         })
+// //     }
+
+// //     pub fn pruned_bundles(&self) -> Result<usize, CompactFiltersError> {
+// //         Ok(self
+// //             .cf_store
+// //             .get_bundles()?
+// //             .into_iter()
+// //             .skip(self.skip_blocks / 1000)
+// //             .fold(0, |acc, (status, _)| match status {
+// //                 BundleStatus::Pruned => acc + 1,
+// //                 _ => acc,
+// //             }))
+// //     }
+
+// //     pub fn prepare_sync(&self, peer: Arc<Peer>) -> Result<(), CompactFiltersError> {
+// //         let mut bundles_lock = self.bundles.lock().unwrap();
+
+// //         let resp = peer.get_cf_checkpt(
+// //             self.cf_store.get_filter_type(),
+// //             self.headers_store.get_tip_hash()?.unwrap(),
+// //         )?;
+// //         self.cf_store.replace_checkpoints(resp.filter_headers)?;
+
+// //         bundles_lock.clear();
+// //         for (index, (status, checkpoint)) in self.cf_store.get_bundles()?.into_iter().enumerate() {
+// //             bundles_lock.push_back((status, checkpoint, index));
+// //         }
+
+// //         Ok(())
+// //     }
+
+// //     pub fn capture_thread_for_sync<F, Q>(
+// //         &self,
+// //         peer: Arc<Peer>,
+// //         process: F,
+// //         completed_bundle: Q,
+// //     ) -> Result<(), CompactFiltersError>
+// //     where
+// //         F: Fn(&BlockHash, &BlockFilter) -> Result<bool, CompactFiltersError>,
+// //         Q: Fn(usize) -> Result<(), Error>,
+// //     {
+// //         let current_height = self.headers_store.get_height()?; // TODO: we should update it in case headers_store is also updated
+
+// //         loop {
+// //             let (mut status, checkpoint, index) = match self.bundles.lock().unwrap().pop_front() {
+// //                 None => break,
+// //                 Some(x) => x,
+// //             };
+
+// //             log::debug!(
+// //                 "Processing bundle #{} - height {} to {}",
+// //                 index,
+// //                 index * 1000 + 1,
+// //                 (index + 1) * 1000
+// //             );
+
+// //             let process_received_filters =
+// //                 |expected_filters| -> Result<BTreeMap<usize, Vec<u8>>, CompactFiltersError> {
+// //                     let mut filters_map = BTreeMap::new();
+// //                     for _ in 0..expected_filters {
+// //                         let filter = peer.pop_cf_filter_resp()?;
+// //                         if filter.filter_type != self.cf_store.get_filter_type() {
+// //                             return Err(CompactFiltersError::InvalidResponse);
+// //                         }
+
+// //                         match self.headers_store.get_height_for(&filter.block_hash)? {
+// //                             Some(height) => filters_map.insert(height, filter.filter),
+// //                             None => return Err(CompactFiltersError::InvalidFilter),
+// //                         };
+// //                     }
+
+// //                     Ok(filters_map)
+// //                 };
+
+// //             let start_height = index * 1000 + 1;
+// //             let mut already_processed = 0;
+
+// //             if start_height < self.skip_blocks {
+// //                 status = self.cf_store.prune_filters(index, checkpoint)?;
+// //             }
+
+// //             let stop_height = std::cmp::min(current_height, start_height + 999);
+// //             let stop_hash = self.headers_store.get_block_hash(stop_height)?.unwrap();
+
+// //             if let BundleStatus::Init = status {
+// //                 log::trace!("status: Init");
+
+// //                 let resp = peer.get_cf_headers(0x00, start_height as u32, stop_hash)?;
+
+//                 assert_eq!(resp.previous_filter_header, checkpoint);
+//                 status =
+//                     self.cf_store
+//                         .advance_to_cf_headers(index, checkpoint, resp.filter_hashes)?;
+//             }
+//             if let BundleStatus::Tip { cf_filters } = status {
+//                 log::trace!("status: Tip (beginning) ");
+
+// //                 already_processed = cf_filters.len();
+// //                 let headers_resp = peer.get_cf_headers(0x00, start_height as u32, stop_hash)?;
+
+// //                 let cf_headers = match self.cf_store.advance_to_cf_headers(
+// //                     index,
+// //                     checkpoint,
+// //                     headers_resp.filter_hashes,
+// //                 )? {
+// //                     BundleStatus::CfHeaders { cf_headers } => cf_headers,
+// //                     _ => return Err(CompactFiltersError::InvalidResponse),
+// //                 };
+
+// //                 peer.get_cf_filters(
+// //                     self.cf_store.get_filter_type(),
+// //                     (start_height + cf_filters.len()) as u32,
+// //                     stop_hash,
+// //                 )?;
+// //                 let expected_filters = stop_height - start_height + 1 - cf_filters.len();
+// //                 let filters_map = process_received_filters(expected_filters)?;
+// //                 let filters = cf_filters
+// //                     .into_iter()
+// //                     .enumerate()
+// //                     .chain(filters_map.into_iter())
+// //                     .collect();
+// //                 status = self
+// //                     .cf_store
+// //                     .advance_to_cf_filters(index, checkpoint, cf_headers, filters)?;
+// //             }
+// //             if let BundleStatus::CfHeaders { cf_headers } = status {
+// //                 log::trace!("status: CFHeaders");
+
+// //                 peer.get_cf_filters(
+// //                     self.cf_store.get_filter_type(),
+// //                     start_height as u32,
+// //                     stop_hash,
+// //                 )?;
+// //                 let expected_filters = stop_height - start_height + 1;
+// //                 let filters_map = process_received_filters(expected_filters)?;
+// //                 status = self.cf_store.advance_to_cf_filters(
+// //                     index,
+// //                     checkpoint,
+// //                     cf_headers,
+// //                     filters_map.into_iter().collect(),
+// //                 )?;
+// //             }
+// //             if let BundleStatus::CFilters { cf_filters } = status {
+// //                 log::trace!("status: CFilters");
+
+// //                 let last_sync_buried_height =
+// //                     (start_height + already_processed).saturating_sub(BURIED_CONFIRMATIONS);
+
+// //                 for (filter_index, filter) in cf_filters.iter().enumerate() {
+// //                     let height = filter_index + start_height;
+
+// //                     // do not download blocks that were already "buried" since the last sync
+// //                     if height < last_sync_buried_height {
+// //                         continue;
+// //                     }
+
+// //                     let block_hash = self.headers_store.get_block_hash(height)?.unwrap();
+
+// //                     // TODO: also download random blocks?
+// //                     if process(&block_hash, &BlockFilter::new(filter))? {
+// //                         log::debug!("Downloading block {}", block_hash);
+
+// //                         let block = peer
+// //                             .get_block(block_hash)?
+// //                             .ok_or(CompactFiltersError::MissingBlock)?;
+// //                         self.headers_store.save_full_block(&block, height)?;
+// //                     }
+// //                 }
+
+// //                 status = BundleStatus::Processed { cf_filters };
+// //             }
+// //             if let BundleStatus::Processed { cf_filters } = status {
+// //                 log::trace!("status: Processed");
+
+// //                 if current_height - stop_height > 1000 {
+// //                     status = self.cf_store.prune_filters(index, checkpoint)?;
+// //                 } else {
+// //                     status = self.cf_store.mark_as_tip(index, cf_filters, checkpoint)?;
+// //                 }
+
+// //                 completed_bundle(index)?;
+// //             }
+// //             if let BundleStatus::Pruned = status {
+// //                 log::trace!("status: Pruned");
+// //             }
+// //             if let BundleStatus::Tip { .. } = status {
+// //                 log::trace!("status: Tip");
+// //             }
+// //         }
+
+// //         Ok(())
+// //     }
+// // }
+
+// // pub fn sync_headers<F>(
+// //     peer: Arc<Peer>,
+// //     store: Arc<ChainStore<Full>>,
+// //     sync_fn: F,
+// // ) -> Result<Option<ChainStore<Snapshot>>, CompactFiltersError>
+// // where
+// //     F: Fn(usize) -> Result<(), Error>,
+// // {
+// //     let locators = store.get_locators()?;
+// //     let locators_vec = locators.iter().map(|(hash, _)| hash).cloned().collect();
+// //     let locators_map: HashMap<_, _> = locators.into_iter().collect();
+
+//     peer.send(NetworkMessage::GetHeaders(GetHeadersMessage::new(
+//         locators_vec,
+//         Hash::all_zeros(),
+//     )))?;
+//     let (mut snapshot, mut last_hash) = if let NetworkMessage::Headers(headers) = peer
+//         .recv("headers", Some(Duration::from_secs(TIMEOUT_SECS)))?
+//         .ok_or(CompactFiltersError::Timeout)?
+//     {
+//         if headers.is_empty() {
+//             return Ok(None);
+//         }
+
+// //         match locators_map.get(&headers[0].prev_blockhash) {
+// //             None => return Err(CompactFiltersError::InvalidHeaders),
+// //             Some(from) => (store.start_snapshot(*from)?, headers[0].prev_blockhash),
+// //         }
+// //     } else {
+// //         return Err(CompactFiltersError::InvalidResponse);
+// //     };
+
+//     let mut sync_height = store.get_height()?;
+//     while sync_height < peer.get_version().start_height as usize {
+//         peer.send(NetworkMessage::GetHeaders(GetHeadersMessage::new(
+//             vec![last_hash],
+//             Hash::all_zeros(),
+//         )))?;
+//         if let NetworkMessage::Headers(headers) = peer
+//             .recv("headers", Some(Duration::from_secs(TIMEOUT_SECS)))?
+//             .ok_or(CompactFiltersError::Timeout)?
+//         {
+//             let batch_len = headers.len();
+//             last_hash = snapshot.apply(sync_height, headers)?;
+
+// //             sync_height += batch_len;
+// //             sync_fn(sync_height)?;
+// //         } else {
+// //             return Err(CompactFiltersError::InvalidResponse);
+// //         }
+// //     }
+
+// //     Ok(Some(snapshot))
+// // }
diff --git a/src/blockchain/mod.rs b/src/blockchain/mod.rs
index 13c0b2a42..1381eed4b 100644
--- a/src/blockchain/mod.rs
+++ b/src/blockchain/mod.rs
@@ -73,7 +73,7 @@ pub use self::esplora::EsploraBlockchain;
 pub mod compact_filters;
 
 #[cfg(feature = "compact_filters")]
-pub use self::compact_filters::CompactFiltersBlockchain;
+pub use self::compact_filters::nakamoto::CbfBlockchain;
 
 /// Capabilities that can be supported by a [`Blockchain`] backend
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
diff --git a/src/error.rs b/src/error.rs
index 0959c60f8..f4d80bcbf 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -135,9 +135,9 @@ pub enum Error {
     #[cfg(feature = "esplora")]
     /// Esplora client error
     Esplora(Box<crate::blockchain::esplora::EsploraError>),
-    #[cfg(feature = "compact_filters")]
-    /// Compact filters client error)
-    CompactFilters(crate::blockchain::compact_filters::CompactFiltersError),
+    // #[cfg(feature = "compact_filters")]
+    // /// Compact filters client error)
+    // CompactFilters(crate::blockchain::compact_filters::CompactFiltersError),
     #[cfg(feature = "compact_filters")]
     /// CBF nakamoto error
     Cbf(crate::blockchain::compact_filters::nakamoto::CbfError),
@@ -323,15 +323,15 @@ impl_error!(bitcoincore_rpc::Error, Rpc);
 #[cfg(feature = "sqlite")]
 impl_error!(rusqlite::Error, Rusqlite);
 
-#[cfg(feature = "compact_filters")]
-impl From<crate::blockchain::compact_filters::CompactFiltersError> for Error {
-    fn from(other: crate::blockchain::compact_filters::CompactFiltersError) -> Self {
-        match other {
-            crate::blockchain::compact_filters::CompactFiltersError::Global(e) => *e,
-            err => Error::CompactFilters(err),
-        }
-    }
-}
+// #[cfg(feature = "compact_filters")]
+// impl From<crate::blockchain::compact_filters::CompactFiltersError> for Error {
+//     fn from(other: crate::blockchain::compact_filters::CompactFiltersError) -> Self {
+//         match other {
+//             crate::blockchain::compact_filters::CompactFiltersError::Global(e) => *e,
+//             err => Error::CompactFilters(err),
+//         }
+//     }
+// }
 
 #[cfg(feature = "compact_filters")]
 impl From<crate::blockchain::compact_filters::nakamoto::CbfError> for Error {

From 7ef378697329902c672fcdac75c76c69ab307a0f Mon Sep 17 00:00:00 2001
From: rajarshimaitra <rajarshi149@gmail.com>
Date: Sun, 26 Feb 2023 15:35:23 +0530
Subject: [PATCH 5/6] nakamoto v0.4.0 update

---
 Cargo.toml                                 |   4 +-
 examples/compact_filters_balance.rs        |   4 +-
 src/blockchain/compact_filters/mod.rs      |  58 +++++-----
 src/blockchain/compact_filters/nakamoto.rs | 122 +++++++++++----------
 src/error.rs                               |   4 +-
 5 files changed, 98 insertions(+), 94 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 18be260b4..752b36447 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -41,8 +41,8 @@ bitcoinconsensus = { version = "0.19.0-3", optional = true }
 bitcoincore-rpc = { version = "0.16", optional = true }
 
 # Nakamoto crates for the CBF blockchain
-nakamoto = { git = "https://github.com/cloudhead/nakamoto.git", rev = "14902d3d5cc9442cdda82419f0f24277d86b243b", optional = true }
-
+# nakamoto = { git = "https://github.com/cloudhead/nakamoto.git", rev = "14902d3d5cc9442cdda82419f0f24277d86b243b", optional = true }
+nakamoto = { version = "0.4.0", optional = true }
 # Platform-specific dependencies
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 tokio = { version = "1", features = ["rt", "macros"] }
diff --git a/examples/compact_filters_balance.rs b/examples/compact_filters_balance.rs
index 1c148bf47..cb534d0f0 100644
--- a/examples/compact_filters_balance.rs
+++ b/examples/compact_filters_balance.rs
@@ -41,6 +41,4 @@
 // }
 
 // TODO make a nakamoto example
-fn main() {
-
-}
+fn main() {}
diff --git a/src/blockchain/compact_filters/mod.rs b/src/blockchain/compact_filters/mod.rs
index 2caeccea3..02f52c993 100644
--- a/src/blockchain/compact_filters/mod.rs
+++ b/src/blockchain/compact_filters/mod.rs
@@ -1,31 +1,31 @@
-// // // Bitcoin Dev Kit
-// // // Written in 2020 by Alekos Filini <alekos.filini@gmail.com>
-// // //
-// // // Copyright (c) 2020-2021 Bitcoin Dev Kit Developers
-// // //
-// // // This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
-// // // or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// // // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
-// // // You may not use this file except in accordance with one or both of these
-// // // licenses.
-
-// //! Compact Filters
-// //!
-// //! This module contains a multithreaded implementation of an [`Blockchain`] backend that
-// //! uses BIP157 (aka "Neutrino") to populate the wallet's [database](crate::database::Database)
-// //! by downloading compact filters from the P2P network.
-// //!
-// //! Since there are currently very few peers "in the wild" that advertise the required service
-// //! flag, this implementation requires that one or more known peers are provided by the user.
-// //! No dns or other kinds of peer discovery are done internally.
-// //!
-// //! Moreover, this module doesn't currently support detecting and resolving conflicts between
-// //! messages received by different peers. Thus, it's recommended to use this module by only
-// //! connecting to a single peer at a time, optionally by opening multiple connections if it's
-// //! desirable to use multiple threads at once to sync in parallel.
-// //!
-// //! This is an **EXPERIMENTAL** feature, API and other major changes are expected.
-// //!
+// Bitcoin Dev Kit
+// Written in 2020 by Alekos Filini <alekos.filini@gmail.com>
+//
+// Copyright (c) 2020-2021 Bitcoin Dev Kit Developers
+//
+// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
+// or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
+// You may not use this file except in accordance with one or both of these
+// licenses.
+
+//! Compact Filters
+//!
+//! This module contains a multithreaded implementation of an [`Blockchain`] backend that
+//! uses BIP157 (aka "Neutrino") to populate the wallet's [database](crate::database::Database)
+//! by downloading compact filters from the P2P network.
+//!
+//! Since there are currently very few peers "in the wild" that advertise the required service
+//! flag, this implementation requires that one or more known peers are provided by the user.
+//! No dns or other kinds of peer discovery are done internally.
+//!
+//! Moreover, this module doesn't currently support detecting and resolving conflicts between
+//! messages received by different peers. Thus, it's recommended to use this module by only
+//! connecting to a single peer at a time, optionally by opening multiple connections if it's
+//! desirable to use multiple threads at once to sync in parallel.
+//!
+//! This is an **EXPERIMENTAL** feature, API and other major changes are expected.
+//!
 // //! ## Example
 // //!
 // //! ```no_run
@@ -68,7 +68,7 @@
 // // mod store;
 // // mod sync;
 
-// pub mod nakamoto;
+pub mod nakamoto;
 
 // use crate::blockchain::*;
 // use crate::database::{BatchDatabase, BatchOperations, DatabaseUtils};
diff --git a/src/blockchain/compact_filters/nakamoto.rs b/src/blockchain/compact_filters/nakamoto.rs
index 6bd544862..734b88e10 100644
--- a/src/blockchain/compact_filters/nakamoto.rs
+++ b/src/blockchain/compact_filters/nakamoto.rs
@@ -24,16 +24,23 @@ use crate::database::{BatchDatabase, BatchOperations, DatabaseUtils};
 use crate::{BlockTime, FeeRate, KeychainKind, LocalUtxo, TransactionDetails};
 use bitcoin::{Block, OutPoint, Script, Transaction, Txid};
 use log::{debug, info};
+use nakamoto::p2p::fsm::fees::FeeEstimate;
 use nakamoto::{
     client::{
-        chan::Receiver, handle::Handle, protocol, protocol::fees::FeeEstimate, spv::TxStatus,
-        Client, Config, Event, Handle as ClientHandle,
+        chan::Receiver,
+        handle::Handle,
+        Client,
+        Config,
+        Event,
+        Handle as ClientHandle,
+        //event::TxStatus
     },
     net::poll::Waker,
 };
-use std::cell::Cell;
+use std::cell::{Cell, RefCell};
 use std::collections::{HashMap, HashSet};
 use std::net::SocketAddr;
+use std::ops::DerefMut;
 use std::path::PathBuf;
 use std::time::Duration;
 use std::{net::TcpStream, thread};
@@ -50,7 +57,7 @@ pub enum CbfError {
 
     /// Nakamoto client error
     #[error(transparent)]
-    Nakamoto(#[from] nakamoto::client::error::Error),
+    Nakamoto(#[from] nakamoto::client::Error),
 }
 
 impl From<crate::error::Error> for CbfError {
@@ -288,12 +295,9 @@ impl CbfBlockchain {
         };
         let cbf_client = Client::<Reactor>::new()?;
         let client_cfg = Config {
+            network: network.into(),
             listen: vec![], // Don't listen for incoming connections.
             root,
-            protocol: protocol::Config {
-                network: network.into(),
-                ..protocol::Config::default()
-            },
             ..Config::default()
         };
 
@@ -301,7 +305,7 @@ impl CbfBlockchain {
         thread::spawn(|| {
             cbf_client.run(client_cfg).unwrap();
         });
-        let receiver = client_handle.subscribe();
+        let receiver = client_handle.events();
 
         Ok(Self {
             receiver,
@@ -472,9 +476,11 @@ impl GetHeight for CbfBlockchain {
 impl WalletSync for CbfBlockchain {
     fn wallet_setup<D: BatchDatabase>(
         &self,
-        database: &mut D,
+        database: &RefCell<D>,
         progress_update: Box<dyn crate::blockchain::Progress>,
     ) -> Result<(), crate::Error> {
+        let mut database = database.borrow_mut();
+        let database = database.deref_mut();
         let db_scripts = database.iter_script_pubkeys(None)?;
         self.client_handle
             .watch(db_scripts.iter().cloned())
@@ -509,27 +515,27 @@ impl WalletSync for CbfBlockchain {
                 Event::BlockConnected { hash, height, .. } => {
                     debug!("New Block Found : {} at {}", hash, height);
                 }
-                // Event::BlockDisconnected { height, .. } => {
-                //     let db_txs = database
-                //         .iter_txs(false)?
-                //         .iter()
-                //         .filter_map(|tx_details| {
-                //             if let Some(block_time) = &tx_details.confirmation_time {
-                //                 if block_time.height == height as u32 {
-                //                     Some(tx_details.txid)
-                //                 } else {
-                //                     None
-                //                 }
-                //             } else {
-                //                 None
-                //             }
-                //         })
-                //         .collect::<HashSet<_>>();
-
-                //     for txid in db_txs {
-                //         unconfirm_tx(database, &txid)?;
-                //     }
-                // }
+                Event::BlockDisconnected { height, .. } => {
+                    let db_txs = database
+                        .iter_txs(false)?
+                        .iter()
+                        .filter_map(|tx_details| {
+                            if let Some(block_time) = &tx_details.confirmation_time {
+                                if block_time.height == height as u32 {
+                                    Some(tx_details.txid)
+                                } else {
+                                    None
+                                }
+                            } else {
+                                None
+                            }
+                        })
+                        .collect::<HashSet<_>>();
+
+                    for txid in db_txs {
+                        unconfirm_tx(database, &txid)?;
+                    }
+                }
                 Event::BlockMatched {
                     hash: _,
                     header,
@@ -568,33 +574,33 @@ impl WalletSync for CbfBlockchain {
                 Event::FeeEstimated { height, fees, .. } => {
                     self.add_fee_data(height as u32, fees);
                 }
-                Event::TxStatusChanged { txid, status } => {
-                    match status {
-                        TxStatus::Unconfirmed => {
-                            debug!("txid:{}, status : Broadcasted", txid);
-                        }
-                        TxStatus::Acknowledged { peer } => {
-                            debug!("txid: {}, status : ACK by {}", txid, peer);
-                        }
-                        TxStatus::Confirmed { height, .. } => {
-                            debug!("txid: {}, status : Confirmed at {}", txid, height);
-                        }
-                        TxStatus::Reverted => {
-                            debug!("Transaction reverted due to reorg: txid : {}", txid);
-                            let _ = unconfirm_tx(database, &txid)?;
-                        }
-                        TxStatus::Stale { replaced_by, block } => {
-                            debug!(
-                                "txid: {}, status : Replaced by : txid {} at blockhash {}",
-                                txid, replaced_by, block
-                            );
-                            let tx = database.get_tx(&replaced_by, true)?.expect(
-                                "Wallet transaction got replaced by unknown foreign transaction",
-                            ); // TODO: Handle the case when we don't have the overriding transaction
-                            delete_tx(database, &tx.txid)?;
-                        }
-                    }
-                }
+                // Event::TxStatusChanged { txid, status } => {
+                //     match status {
+                //         TxStatus::Unconfirmed => {
+                //             debug!("txid:{}, status : Broadcasted", txid);
+                //         }
+                //         TxStatus::Acknowledged { peer } => {
+                //             debug!("txid: {}, status : ACK by {}", txid, peer);
+                //         }
+                //         TxStatus::Confirmed { height, .. } => {
+                //             debug!("txid: {}, status : Confirmed at {}", txid, height);
+                //         }
+                //         TxStatus::Reverted => {
+                //             debug!("Transaction reverted due to reorg: txid : {}", txid);
+                //             let _ = unconfirm_tx(database, &txid)?;
+                //         }
+                //         TxStatus::Stale { replaced_by, block } => {
+                //             debug!(
+                //                 "txid: {}, status : Replaced by : txid {} at blockhash {}",
+                //                 txid, replaced_by, block
+                //             );
+                //             let tx = database.get_tx(&replaced_by, true)?.expect(
+                //                 "Wallet transaction got replaced by unknown foreign transaction",
+                //             ); // TODO: Handle the case when we don't have the overriding transaction
+                //             delete_tx(database, &tx.txid)?;
+                //         }
+                //     }
+                // }
                 Event::Synced { height, tip } => {
                     debug!("Sync Status : {}:{}", height, tip);
                     progress_update.update(
diff --git a/src/error.rs b/src/error.rs
index f4d80bcbf..fd0ca0398 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -140,7 +140,7 @@ pub enum Error {
     // CompactFilters(crate::blockchain::compact_filters::CompactFiltersError),
     #[cfg(feature = "compact_filters")]
     /// CBF nakamoto error
-    Cbf(crate::blockchain::compact_filters::nakamoto::CbfError),
+    CompactFilters(crate::blockchain::compact_filters::nakamoto::CbfError),
     #[cfg(feature = "key-value-db")]
     /// Sled database error
     Sled(sled::Error),
@@ -338,7 +338,7 @@ impl From<crate::blockchain::compact_filters::nakamoto::CbfError> for Error {
     fn from(other: crate::blockchain::compact_filters::nakamoto::CbfError) -> Self {
         match other {
             crate::blockchain::compact_filters::nakamoto::CbfError::Global(e) => *e,
-            err => Error::Cbf(err),
+            err => Error::CompactFilters(err),
         }
     }
 }

From 5e9603cb87d843c3d856c6e478c0850289f77fbb Mon Sep 17 00:00:00 2001
From: rajarshimaitra <rajarshi149@gmail.com>
Date: Sun, 26 Feb 2023 22:19:05 +0530
Subject: [PATCH 6/6] Add initial peer list into config.

---
 src/blockchain/compact_filters/nakamoto.rs | 62 +++++++++++++++-------
 1 file changed, 42 insertions(+), 20 deletions(-)

diff --git a/src/blockchain/compact_filters/nakamoto.rs b/src/blockchain/compact_filters/nakamoto.rs
index 734b88e10..3b9f11c93 100644
--- a/src/blockchain/compact_filters/nakamoto.rs
+++ b/src/blockchain/compact_filters/nakamoto.rs
@@ -283,11 +283,17 @@ pub struct CBFBlockchainConfig {
     pub network: bitcoin::Network,
     /// Optional custom datadir for CBF Client
     pub datadir: Option<PathBuf>,
+    /// Initial Peer List
+    pub peers: Vec<SocketAddr>,
 }
 
 impl CbfBlockchain {
     /// Create a new CBF node which runs at the background.
-    pub fn new(network: bitcoin::Network, datadir: Option<PathBuf>) -> Result<Self, CbfError> {
+    pub fn new(
+        network: bitcoin::Network,
+        datadir: Option<PathBuf>,
+        peers: Vec<SocketAddr>,
+    ) -> Result<Self, CbfError> {
         let root = if let Some(dir) = datadir {
             dir
         } else {
@@ -307,6 +313,13 @@ impl CbfBlockchain {
         });
         let receiver = client_handle.events();
 
+        for peer in peers {
+            let peer_link = client_handle
+                .connect(peer)
+                .map_err(nakamoto::client::Error::from)?;
+            debug!("New peer connected : {:?}", peer_link);
+        }
+
         Ok(Self {
             receiver,
             client_handle,
@@ -333,18 +346,18 @@ impl CbfBlockchain {
         self.fee_data.set(data)
     }
 
-    /// Connect the client with a specific peer.
-    pub fn add_peers(&self, peers: Vec<SocketAddr>) -> Result<Vec<SocketAddr>, CbfError> {
-        let mut connected_peers = vec![];
-        for peer in peers {
-            let _ = self
-                .client_handle
-                .connect(peer)
-                .map_err(nakamoto::client::Error::from)?;
-            connected_peers.push(peer);
-        }
-        Ok(connected_peers)
-    }
+    // /// Connect the client with a specific peer.
+    // pub fn add_peers(&self, peers: Vec<SocketAddr>) -> Result<Vec<SocketAddr>, CbfError> {
+    //     let mut connected_peers = vec![];
+    //     for peer in peers {
+    //         let _ = self
+    //             .client_handle
+    //             .connect(peer)
+    //             .map_err(nakamoto::client::Error::from)?;
+    //         connected_peers.push(peer);
+    //     }
+    //     Ok(connected_peers)
+    // }
 
     /// Disconnect the client from a specific peer
     pub fn diconnect(&self, peer: SocketAddr) {
@@ -657,7 +670,11 @@ impl ConfigurableBlockchain for CbfBlockchain {
     type Config = CBFBlockchainConfig;
 
     fn from_config(config: &Self::Config) -> Result<Self, crate::Error> {
-        Ok(Self::new(config.network, config.datadir.clone())?)
+        Ok(Self::new(
+            config.network,
+            config.datadir.clone(),
+            config.peers,
+        )?)
     }
 }
 
@@ -680,14 +697,19 @@ mod test {
 
             let mut root = std::env::temp_dir();
             root = root.join(addrs);
-            let cbf_node = CbfBlockchain::new(Network::Regtest, Some(root)).unwrap();
 
             let bitcoind_p2p_port = test_client
-                .bitcoind
-                .params
-                .p2p_socket
-                .expect("Bitcoin P2P Port should be available");
-            cbf_node.add_peers(vec![bitcoind_p2p_port.into()]).unwrap();
+            .bitcoind
+            .params
+            .p2p_socket
+            .expect("Bitcoin P2P Port should be available");
+
+            let config = CBFBlockchainConfig {
+                network: Network::Regtest,
+                datadir: Some(root),
+                peers: vec![bitcoind_p2p_port.into()]
+            };
+            let cbf_node = CbfBlockchain::from_config(&config).unwrap();
 
             cbf_node
         }