Update CI blockchain tests

(cherry picked from commit 10b53a56d7)
Test refactor
2021-09-15 13:44:11 -07:00 · 2021-09-15 13:44:09 -07:00 · 2021-09-15 13:44:06 -07:00 · 2021-09-15 13:44:04 -07:00 · 2021-09-04 11:43:24 -07:00 · 2021-09-04 10:46:03 -07:00
33 changed files with 1328 additions and 1002 deletions
--- a/.github/workflows/code_coverage.yml
+++ b/.github/workflows/code_coverage.yml
@@ -24,7 +24,7 @@ jobs:
      - name: Update toolchain
        run: rustup update
      - name: Test
-        run: cargo test --features all-keys,compiler,esplora,compact_filters --no-default-features
+        run: cargo test --features all-keys,compiler,esplora,ureq,compact_filters --no-default-features
                    
      - id: coverage
        name: Generate coverage
--- a/.github/workflows/cont_integration.yml
+++ b/.github/workflows/cont_integration.yml
@@ -16,14 +16,16 @@ jobs:
          - default
          - minimal
          - all-keys
-          - minimal,esplora
+          - minimal,use-esplora-ureq
          - key-value-db
          - electrum
          - compact_filters
-          - esplora,key-value-db,electrum
+          - esplora,ureq,key-value-db,electrum
          - compiler
          - rpc
          - verify
+          - async-interface
+          - use-esplora-reqwest
    steps:
      - name: checkout
        uses: actions/checkout@v2
@@ -76,29 +78,20 @@ jobs:
        run: cargo test --features test-md-docs --no-default-features -- doctest::ReadmeDoctests

  test-blockchains:
-    name: Test ${{ matrix.blockchain.name }}
-    runs-on: ubuntu-16.04
+    name: Blockchain ${{ matrix.blockchain.features }}
+    runs-on: ubuntu-20.04
    strategy:
      fail-fast: false
      matrix:
        blockchain:
          - name: electrum
-            container: bitcoindevkit/electrs:0.4.0
-            start: /root/electrs --network regtest --cookie-file $GITHUB_WORKSPACE/.bitcoin/regtest/.cookie --jsonrpc-import
-          - name: esplora
-            container: bitcoindevkit/esplora:0.4.0
-            start: /root/electrs --network regtest -vvv --daemon-dir $GITHUB_WORKSPACE/.bitcoin --jsonrpc-import --electrum-rpc-addr=0.0.0.0:60401 --http-addr 0.0.0.0:3002
+            features: test-electrum
          - name: rpc
-            container: bitcoindevkit/electrs:0.4.0
-            start: /root/electrs --network regtest --cookie-file $GITHUB_WORKSPACE/.bitcoin/regtest/.cookie --jsonrpc-import
-    container: ${{ matrix.blockchain.container }}
-    env:
-      BDK_RPC_AUTH: COOKIEFILE
-      BDK_RPC_COOKIEFILE: ${{ github.workspace }}/.bitcoin/regtest/.cookie
-      BDK_RPC_URL: 127.0.0.1:18443
-      BDK_RPC_WALLET: bdk-test
-      BDK_ELECTRUM_URL: tcp://127.0.0.1:60401
-      BDK_ESPLORA_URL: http://127.0.0.1:3002
+            features: test-rpc
+          - name: esplora
+            features: test-esplora,use-esplora-reqwest
+          - name: esplora
+            features: test-esplora,use-esplora-ureq    
    steps:
      - name: Checkout
        uses: actions/checkout@v2
@@ -110,23 +103,14 @@ jobs:
            ~/.cargo/git
            target
          key: ${{ runner.os }}-cargo-${{ github.job }}-${{ hashFiles('**/Cargo.toml','**/Cargo.lock') }}
-      - name: get pkg-config # running esplora tests seems to need this
-        run: apt update && apt install -y --fix-missing pkg-config libssl-dev
-      - name: Install rustup
-        run: curl https://sh.rustup.rs -sSf | sh -s -- -y
-      - name: Set default toolchain
-        run: $HOME/.cargo/bin/rustup default 1.53.0 # STABLE
-      - name: Set profile
-        run: $HOME/.cargo/bin/rustup set profile minimal
-      - name: Update toolchain
-        run: $HOME/.cargo/bin/rustup update
-      - name: Start core
-        run: ./ci/start-core.sh
-      - name: start ${{ matrix.blockchain.name }}
-        run: nohup ${{ matrix.blockchain.start }} & sleep 5
+      - name: Setup rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          override: true
      - name: Test
-        run: $HOME/.cargo/bin/cargo test --features test-${{ matrix.blockchain.name }},test-blockchains --no-default-features ${{ matrix.blockchain.name }}::bdk_blockchain_tests
-
+        run: cargo test --no-default-features --features ${{ matrix.blockchain.features }} ${{ matrix.blockchain.name }}::bdk_blockchain_tests
+  
  check-wasm:
    name: Check WASM
    runs-on: ubuntu-16.04
@@ -158,7 +142,7 @@ jobs:
      - name: Update toolchain
        run: rustup update
      - name: Check
-        run: cargo check --target wasm32-unknown-unknown --features esplora --no-default-features
+        run: cargo check --target wasm32-unknown-unknown --features use-esplora-reqwest --no-default-features

  fmt:
    name: Rust fmt
--- a/.github/workflows/nightly_docs.yml
+++ b/.github/workflows/nightly_docs.yml
@@ -24,7 +24,7 @@ jobs:
      - name: Update toolchain
        run: rustup update
      - name: Build docs
-        run: cargo rustdoc --verbose --features=compiler,electrum,esplora,compact_filters,key-value-db,all-keys -- --cfg docsrs -Dwarnings
+        run: cargo rustdoc --verbose --features=compiler,electrum,esplora,ureq,compact_filters,key-value-db,all-keys -- --cfg docsrs -Dwarnings
      - name: Upload artifact
        uses: actions/upload-artifact@v2
        with:
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,12 +6,30 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0

 ## [Unreleased]

+## [v0.11.0] - [v0.10.0]
+
+- Added `flush` method to the `Database` trait to explicitly flush to disk latest changes on the db.
+
+## [v0.10.0] - [v0.9.0]
+
+- Added `RpcBlockchain` in the `AnyBlockchain` struct to allow using Rpc backend where `AnyBlockchain` is used (eg `bdk-cli`)
+- Removed hard dependency on `tokio`.
+
+### Wallet
+
+- Removed and replaced `set_single_recipient` with more general `drain_to` and replaced `maintain_single_recipient` with `allow_shrinking`.
+
+### Blockchain
+
+- Removed `stop_gap` from `Blockchain` trait and added it to only `ElectrumBlockchain` and `EsploraBlockchain` structs.
+- Added a `ureq` backend for use when not using feature `async-interface` or target WASM. `ureq` is a blocking HTTP client.
+
 ## [v0.9.0] - [v0.8.0]

 ### Wallet
-#### Added
- Bitcoin core RPC added as blockchain backend
- Add a `verify` feature that can be enable to verify the unconfirmed txs we download against the consensus rules
+
+- Added Bitcoin core RPC added as blockchain backend
+- Added a `verify` feature that can be enable to verify the unconfirmed txs we download against the consensus rules

 ## [v0.8.0] - [v0.7.0]

@@ -346,7 +364,7 @@ final transaction is created by calling `finish` on the builder.
 - Use `MemoryDatabase` in the compiler example
 - Make the REPL return JSON

-[unreleased]: https://github.com/bitcoindevkit/bdk/compare/v0.9.0...HEAD
+[unreleased]: https://github.com/bitcoindevkit/bdk/compare/v0.11.0...HEAD
 [0.1.0-beta.1]: https://github.com/bitcoindevkit/bdk/compare/96c87ea5...0.1.0-beta.1
 [v0.2.0]: https://github.com/bitcoindevkit/bdk/compare/0.1.0-beta.1...v0.2.0
 [v0.3.0]: https://github.com/bitcoindevkit/bdk/compare/v0.2.0...v0.3.0
@@ -357,3 +375,5 @@ final transaction is created by calling `finish` on the builder.
 [v0.7.0]: https://github.com/bitcoindevkit/bdk/compare/v0.6.0...v0.7.0
 [v0.8.0]: https://github.com/bitcoindevkit/bdk/compare/v0.7.0...v0.8.0
 [v0.9.0]: https://github.com/bitcoindevkit/bdk/compare/v0.8.0...v0.9.0
+[v0.10.0]: https://github.com/bitcoindevkit/bdk/compare/v0.9.0...v0.10.0
+[v0.11.0]: https://github.com/bitcoindevkit/bdk/compare/v0.10.0...v0.11.0
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -57,6 +57,21 @@ comment suggesting that you're working on it. If someone is already assigned,
 don't hesitate to ask if the assigned party or previous commenters are still
 working on it if it has been awhile.

+Deprecation policy
+------------------
+
+Where possible, breaking existing APIs should be avoided. Instead, add new APIs and
+use [`#[deprecated]`](https://github.com/rust-lang/rfcs/blob/master/text/1270-deprecation.md)
+to discourage use of the old one.
+
+Deprecated APIs are typically maintained for one release cycle. In other words, an
+API that has been deprecated with the 0.10 release can be expected to be removed in the
+0.11 release. This allows for smoother upgrades without incurring too much technical
+debt inside this library.
+
+If you deprecated an API as part of a contribution, we encourage you to "own" that API
+and send a follow-up to remove it as part of the next release cycle.
+
 Peer review
 -----------

--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bdk"
-version = "0.9.0"
+version = "0.11.1-dev"
 edition = "2018"
 authors = ["Alekos Filini <alekos.filini@gmail.com>", "Riccardo Casatta <riccardo@casatta.it>"]
 homepage = "https://bitcoindevkit.org"
@@ -12,30 +12,31 @@ readme = "README.md"
 license = "MIT OR Apache-2.0"

 [dependencies]
-bdk-macros = "^0.4"
+bdk-macros = { path = "macros"} # TODO: Change this to version number after next release.
 log = "^0.4"
-miniscript = "5.1"
-bitcoin = { version = "~0.26.2", features = ["use-serde", "base64"] }
+miniscript = "^6.0"
+bitcoin = { version = "^0.27", features = ["use-serde", "base64"] }
 serde = { version = "^1.0", features = ["derive"] }
 serde_json = { version = "^1.0" }
 rand = "^0.7"

 # Optional dependencies
 sled = { version = "0.34", optional = true }
-electrum-client = { version = "0.7", optional = true }
+electrum-client = { version = "0.8", optional = true }
 reqwest = { version = "0.11", optional = true, features = ["json"] }
+ureq = { version = "2.1", default-features = false, features = ["json"], optional = true }
 futures = { version = "0.3", optional = true }
 async-trait = { version = "0.1", optional = true }
-rocksdb = { version = "0.14", optional = true }
+rocksdb = { version = "0.14", default-features = false, features = ["snappy"], optional = true }
 cc = { version = ">=1.0.64", optional = true }
 socks = { version = "0.3", optional = true }
 lazy_static = { version = "1.4", optional = true }
 tiny-bip39 = { version = "^0.8", optional = true }
+zeroize = { version = "<1.4.0", optional = true }
 bitcoinconsensus = { version = "0.19.0-3", optional = true }

 # Needed by bdk_blockchain_tests macro
-bitcoincore-rpc = { version = "0.13", optional = true }
-serial_test = { version = "0.4", optional = true }
+core-rpc = { version = "0.14", optional = true }

 # Platform-specific dependencies
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
@@ -51,29 +52,46 @@ minimal = []
 compiler = ["miniscript/compiler"]
 verify = ["bitcoinconsensus"]
 default = ["key-value-db", "electrum"]
-electrum = ["electrum-client"]
-esplora = ["reqwest", "futures"]
 compact_filters = ["rocksdb", "socks", "lazy_static", "cc"]
 key-value-db = ["sled"]
-async-interface = ["async-trait"]
 all-keys = ["keys-bip39"]
-keys-bip39 = ["tiny-bip39"]
-rpc = ["bitcoincore-rpc"]
+keys-bip39 = ["tiny-bip39", "zeroize"]
+rpc = ["core-rpc"]
+
+# We currently provide mulitple implementations of `Blockchain`, all are
+# blocking except for the `EsploraBlockchain` which can be either async or
+# blocking, depending on the HTTP client in use.
+#
+# - Users wanting asynchronous HTTP calls should enable `async-interface` to get
+#   access to the asynchronous method implementations. Then, if Esplora is wanted,
+#   enable `esplora` AND `reqwest` (`--features=use-esplora-reqwest`).
+# - Users wanting blocking HTTP calls can use any of the other blockchain
+#   implementations (`compact_filters`, `electrum`, or `esplora`). Users wanting to
+#   use Esplora should enable `esplora` AND `ureq`  (`--features=use-esplora-ureq`).
+#
+# WARNING: Please take care with the features below, various combinations will
+# fail to build. We cannot currently build `bdk` with `--all-features`.
+async-interface = ["async-trait"]
+electrum = ["electrum-client"]
+# MUST ALSO USE `--no-default-features`.
+use-esplora-reqwest = ["esplora", "reqwest", "futures"]
+use-esplora-ureq = ["esplora", "ureq"]
+# Typical configurations will not need to use `esplora` feature directly.
+esplora = []


 # Debug/Test features
-test-blockchains = ["bitcoincore-rpc", "electrum-client"]
-test-electrum = ["electrum"]
-test-rpc = ["rpc"]
-test-esplora = ["esplora"]
+test-blockchains = ["core-rpc", "electrum-client"]
+test-electrum = ["electrum", "electrsd/electrs_0_8_10", "test-blockchains"]
+test-rpc = ["rpc", "electrsd/electrs_0_8_10", "test-blockchains"]
+test-esplora = ["electrsd/legacy", "electrsd/esplora_a33e97e1", "test-blockchains"]
 test-md-docs = ["electrum"]

 [dev-dependencies]
 lazy_static = "1.4"
 env_logger = "0.7"
 clap = "2.33"
-serial_test = "0.4"
-bitcoind = "0.10.0"
+electrsd = { version= "0.10", features = ["trigger", "bitcoind_0_21_1"] }

 [[example]]
 name = "address_validator"
@@ -89,6 +107,6 @@ required-features = ["compiler"]
 [workspace]
 members = ["macros"]
 [package.metadata.docs.rs]
-features = ["compiler", "electrum", "esplora", "compact_filters", "rpc", "key-value-db", "all-keys", "verify"]
+features = ["compiler", "electrum", "esplora", "ureq", "compact_filters", "rpc", "key-value-db", "all-keys", "verify"]
 # defines the configuration attribute `docsrs`
 rustdoc-args = ["--cfg", "docsrs"]
--- a/README.md
+++ b/README.md
@@ -151,6 +151,25 @@ fn main() -> Result<(), bdk::Error> {
 }
 ```

+## Testing
+
+### Unit testing
+
+```
+cargo test
+```
+
+### Integration testing
+
+Integration testing require testing features, for example:
+
+```
+cargo test --features test-electrum
+```
+
+The other options are `test-esplora` or `test-rpc`.
+Note that `electrs` and `bitcoind` binaries are automatically downloaded (on mac and linux), to specify you already have installed binaries you must use `--no-default-features` and provide `BITCOIND_EXE` and `ELECTRS_EXE` as environment variables.
+
 ## License

 Licensed under either of
--- a/macros/Cargo.toml
+++ b/macros/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bdk-macros"
-version = "0.4.0"
+version = "0.5.0"
 authors = ["Alekos Filini <alekos.filini@gmail.com>"]
 edition = "2018"
 homepage = "https://bitcoindevkit.org"
--- a/run_blockchain_tests.sh
+++ b/run_blockchain_tests.sh
@@ -1,71 +0,0 @@
-#!/bin/sh
-
-usage() {
-    cat <<'EOF'
-Script for running the bdk blockchain tests for a specific blockchain by starting up the backend in docker.
-
-Usage: ./run_blockchain_tests.sh [esplora|electrum|rpc] [test name].
-
-EOF
-}
-
-eprintln(){
-    echo "$@" >&2
-}
-
-cleanup() {
-    if test "$id"; then
-        eprintln "cleaning up $blockchain docker container $id";
-        docker rm -fv "$id" > /dev/null;
-        rm /tmp/regtest-"$id".cookie;
-    fi
-    trap - EXIT INT
-}
-
-# Makes sure we clean up the container at the end or if ^C
-trap 'rc=$?; cleanup; exit $rc' EXIT INT
-
-blockchain="$1"
-test_name="$2"
-
-case "$blockchain" in
-    electrum)
-        eprintln "starting electrs docker container"
-        id="$(docker run --detach -p 127.0.0.1:18443-18444:18443-18444/tcp -p 127.0.0.1:60401:60401/tcp bitcoindevkit/electrs:0.4.0)"
-        ;;
-    esplora)
-        eprintln "starting esplora docker container"
-        id="$(docker run --detach -p 127.0.0.1:18443-18444:18443-18444/tcp -p 127.0.0.1:60401:60401/tcp -p 127.0.0.1:3002:3002/tcp bitcoindevkit/esplora:0.4.0)"
-        export BDK_ESPLORA_URL=http://127.0.0.1:3002
-        ;;
-    rpc)
-        eprintln "starting bitcoind docker container (via electrs container)"
-        id="$(docker run --detach -p 127.0.0.1:18443-18444:18443-18444/tcp -p 127.0.0.1:60401:60401/tcp bitcoindevkit/electrs:0.4.0)"      
-        ;;
-    *)
-        usage;
-        exit 1;
-        ;;
-    esac
-
-# taken from https://github.com/bitcoindevkit/bitcoin-regtest-box
-export BDK_RPC_AUTH=COOKIEFILE
-export BDK_RPC_COOKIEFILE=/tmp/regtest-"$id".cookie
-export BDK_RPC_URL=127.0.0.1:18443
-export BDK_RPC_WALLET=bdk-test
-export BDK_ELECTRUM_URL=tcp://127.0.0.1:60401
-
-cli(){
-    docker exec -it "$id" /root/bitcoin-cli -regtest -datadir=/root/.bitcoin $@
-}
-
-#eprintln "running getwalletinfo until bitcoind seems to be alive"
-while ! cli getwalletinfo >/dev/null; do sleep 1; done
-
-# sleep again for good measure!
-sleep 1;
-
-# copy bitcoind cookie file to /tmp
-docker cp "$id":/root/.bitcoin/regtest/.cookie /tmp/regtest-"$id".cookie
-
-cargo test --features "test-blockchains,test-$blockchain" --no-default-features "$blockchain::bdk_blockchain_tests::$test_name"
--- a/src/blockchain/any.rs
+++ b/src/blockchain/any.rs
@@ -37,9 +37,9 @@
 //! )?;
 //! # }
 //!
-//! # #[cfg(feature = "esplora")]
+//! # #[cfg(all(feature = "esplora", feature = "ureq"))]
 //! # {
-//! let esplora_blockchain = EsploraBlockchain::new("...", None);
+//! let esplora_blockchain = EsploraBlockchain::new("...", 20);
 //! let wallet_esplora: Wallet<AnyBlockchain, _> = Wallet::new(
 //!     "...",
 //!     None,
@@ -60,6 +60,8 @@
 //! # use bdk::blockchain::*;
 //! # use bdk::database::MemoryDatabase;
 //! # use bdk::Wallet;
+//! # #[cfg(all(feature = "esplora", feature = "ureq"))]
+//! # {
 //! let config = serde_json::from_str("...")?;
 //! let blockchain = AnyBlockchain::from_config(&config)?;
 //! let wallet = Wallet::new(
@@ -69,6 +71,7 @@
 //!     MemoryDatabase::default(),
 //!     blockchain,
 //! )?;
+//! # }
 //! # Ok::<(), bdk::Error>(())
 //! ```

@@ -94,6 +97,8 @@ macro_rules! impl_inner_method {
            AnyBlockchain::Esplora(inner) => inner.$name( $($args, )* ),
            #[cfg(feature = "compact_filters")]
            AnyBlockchain::CompactFilters(inner) => inner.$name( $($args, )* ),
+            #[cfg(feature = "rpc")]
+            AnyBlockchain::Rpc(inner) => inner.$name( $($args, )* ),
        }
    }
 }
@@ -116,6 +121,10 @@ pub enum AnyBlockchain {
    #[cfg_attr(docsrs, doc(cfg(feature = "compact_filters")))]
    /// Compact filters client
    CompactFilters(compact_filters::CompactFiltersBlockchain),
+    #[cfg(feature = "rpc")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "rpc")))]
+    /// RPC client
+    Rpc(rpc::RpcBlockchain),
 }

 #[maybe_async]
@@ -126,31 +135,17 @@ impl Blockchain for AnyBlockchain {

    fn setup<D: BatchDatabase, P: 'static + Progress>(
        &self,
-        stop_gap: Option<usize>,
        database: &mut D,
        progress_update: P,
    ) -> Result<(), Error> {
-        maybe_await!(impl_inner_method!(
-            self,
-            setup,
-            stop_gap,
-            database,
-            progress_update
-        ))
+        maybe_await!(impl_inner_method!(self, setup, database, progress_update))
    }
    fn sync<D: BatchDatabase, P: 'static + Progress>(
        &self,
-        stop_gap: Option<usize>,
        database: &mut D,
        progress_update: P,
    ) -> Result<(), Error> {
-        maybe_await!(impl_inner_method!(
-            self,
-            sync,
-            stop_gap,
-            database,
-            progress_update
-        ))
+        maybe_await!(impl_inner_method!(self, sync, database, progress_update))
    }

    fn get_tx(&self, txid: &Txid) -> Result<Option<Transaction>, Error> {
@@ -171,6 +166,7 @@ impl Blockchain for AnyBlockchain {
 impl_from!(electrum::ElectrumBlockchain, AnyBlockchain, Electrum, #[cfg(feature = "electrum")]);
 impl_from!(esplora::EsploraBlockchain, AnyBlockchain, Esplora, #[cfg(feature = "esplora")]);
 impl_from!(compact_filters::CompactFiltersBlockchain, AnyBlockchain, CompactFilters, #[cfg(feature = "compact_filters")]);
+impl_from!(rpc::RpcBlockchain, AnyBlockchain, Rpc, #[cfg(feature = "rpc")]);

 /// Type that can contain any of the blockchain configurations defined by the library
 ///
@@ -188,7 +184,8 @@ impl_from!(compact_filters::CompactFiltersBlockchain, AnyBlockchain, CompactFilt
 ///     r#"{
 ///    "type" : "electrum",
 ///    "url" : "ssl://electrum.blockstream.info:50002",
-///    "retry": 2
+///    "retry": 2,
+///    "stop_gap": 20
 /// }"#,
 /// )
 /// .unwrap();
@@ -198,7 +195,8 @@ impl_from!(compact_filters::CompactFiltersBlockchain, AnyBlockchain, CompactFilt
 ///         url: "ssl://electrum.blockstream.info:50002".into(),
 ///         retry: 2,
 ///         socks5: None,
-///         timeout: None
+///         timeout: None,
+///         stop_gap: 20,
 ///     })
 /// );
 /// # }
@@ -218,6 +216,10 @@ pub enum AnyBlockchainConfig {
    #[cfg_attr(docsrs, doc(cfg(feature = "compact_filters")))]
    /// Compact filters client
    CompactFilters(compact_filters::CompactFiltersBlockchainConfig),
+    #[cfg(feature = "rpc")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "rpc")))]
+    /// RPC client configuration
+    Rpc(rpc::RpcConfig),
 }

 impl ConfigurableBlockchain for AnyBlockchain {
@@ -237,6 +239,10 @@ impl ConfigurableBlockchain for AnyBlockchain {
            AnyBlockchainConfig::CompactFilters(inner) => AnyBlockchain::CompactFilters(
                compact_filters::CompactFiltersBlockchain::from_config(inner)?,
            ),
+            #[cfg(feature = "rpc")]
+            AnyBlockchainConfig::Rpc(inner) => {
+                AnyBlockchain::Rpc(rpc::RpcBlockchain::from_config(inner)?)
+            }
        })
    }
 }
@@ -244,3 +250,4 @@ 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!(rpc::RpcConfig, AnyBlockchainConfig, Rpc, #[cfg(feature = "rpc")]);
--- a/src/blockchain/compact_filters/mod.rs
+++ b/src/blockchain/compact_filters/mod.rs
@@ -229,7 +229,6 @@ impl Blockchain for CompactFiltersBlockchain {
    #[allow(clippy::mutex_atomic)] // Mutex is easier to understand than a CAS loop.
    fn setup<D: BatchDatabase, P: 'static + Progress>(
        &self,
-        _stop_gap: Option<usize>, // TODO: move to electrum and esplora only
        database: &mut D,
        progress_update: P,
    ) -> Result<(), Error> {
--- a/src/blockchain/electrum.rs
+++ b/src/blockchain/electrum.rs
@@ -43,11 +43,17 @@ use crate::FeeRate;
 ///
 /// ## Example
 /// See the [`blockchain::electrum`](crate::blockchain::electrum) module for a usage example.
-pub struct ElectrumBlockchain(Client);
+pub struct ElectrumBlockchain {
+    client: Client,
+    stop_gap: usize,
+}

 impl std::convert::From<Client> for ElectrumBlockchain {
    fn from(client: Client) -> Self {
-        ElectrumBlockchain(client)
+        ElectrumBlockchain {
+            client,
+            stop_gap: 20,
+        }
    }
 }

@@ -64,34 +70,33 @@ impl Blockchain for ElectrumBlockchain {

    fn setup<D: BatchDatabase, P: Progress>(
        &self,
-        stop_gap: Option<usize>,
        database: &mut D,
        progress_update: P,
    ) -> Result<(), Error> {
-        self.0
-            .electrum_like_setup(stop_gap, database, progress_update)
+        self.client
+            .electrum_like_setup(self.stop_gap, database, progress_update)
    }

    fn get_tx(&self, txid: &Txid) -> Result<Option<Transaction>, Error> {
-        Ok(self.0.transaction_get(txid).map(Option::Some)?)
+        Ok(self.client.transaction_get(txid).map(Option::Some)?)
    }

    fn broadcast(&self, tx: &Transaction) -> Result<(), Error> {
-        Ok(self.0.transaction_broadcast(tx).map(|_| ())?)
+        Ok(self.client.transaction_broadcast(tx).map(|_| ())?)
    }

    fn get_height(&self) -> Result<u32, Error> {
        // TODO: unsubscribe when added to the client, or is there a better call to use here?

        Ok(self
-            .0
+            .client
            .block_headers_subscribe()
            .map(|data| data.height as u32)?)
    }

    fn estimate_fee(&self, target: usize) -> Result<FeeRate, Error> {
        Ok(FeeRate::from_btc_per_kvb(
-            self.0.estimate_fee(target)? as f32
+            self.client.estimate_fee(target)? as f32
        ))
    }
 }
@@ -149,6 +154,8 @@ pub struct ElectrumBlockchainConfig {
    pub retry: u8,
    /// Request timeout (seconds)
    pub timeout: Option<u8>,
+    /// Stop searching addresses for transactions after finding an unused gap of this length
+    pub stop_gap: usize,
 }

 impl ConfigurableBlockchain for ElectrumBlockchain {
@@ -162,16 +169,17 @@ impl ConfigurableBlockchain for ElectrumBlockchain {
            .socks5(socks5)?
            .build();

-        Ok(ElectrumBlockchain(Client::from_config(
-            config.url.as_str(),
-            electrum_config,
-        )?))
+        Ok(ElectrumBlockchain {
+            client: Client::from_config(config.url.as_str(), electrum_config)?,
+            stop_gap: config.stop_gap,
+        })
    }
 }

-#[cfg(feature = "test-blockchains")]
+#[cfg(test)]
+#[cfg(feature = "test-electrum")]
 crate::bdk_blockchain_tests! {
-    fn test_instance() -> ElectrumBlockchain {
-        ElectrumBlockchain::from(Client::new(&testutils::blockchain_tests::get_electrum_url()).unwrap())
+    fn test_instance(test_client: &TestClient) -> ElectrumBlockchain {
+        ElectrumBlockchain::from(Client::new(&test_client.electrsd.electrum_url).unwrap())
    }
 }
--- a/src/blockchain/esplora/mod.rs
+++ b/src/blockchain/esplora/mod.rs
@@ -0,0 +1,129 @@
+//! Esplora
+//!
+//! This module defines a [`EsploraBlockchain`] struct that can query an Esplora
+//! backend populate the wallet's [database](crate::database::Database) by:
+//!
+//! ## Example
+//!
+//! ```no_run
+//! # use bdk::blockchain::esplora::EsploraBlockchain;
+//! let blockchain = EsploraBlockchain::new("https://blockstream.info/testnet/api", 20);
+//! # Ok::<(), bdk::Error>(())
+//! ```
+//!
+//! Esplora blockchain can use either `ureq` or `reqwest` for the HTTP client
+//! depending on your needs (blocking or async respectively).
+//!
+//! Please note, to configure the Esplora HTTP client correctly use one of:
+//! Blocking:  --features='esplora,ureq'
+//! Async:     --features='async-interface,esplora,reqwest' --no-default-features
+use std::collections::HashMap;
+use std::fmt;
+use std::io;
+
+use serde::Deserialize;
+
+use bitcoin::consensus;
+use bitcoin::{BlockHash, Txid};
+
+use crate::error::Error;
+use crate::FeeRate;
+
+#[cfg(feature = "reqwest")]
+mod reqwest;
+
+#[cfg(feature = "reqwest")]
+pub use self::reqwest::*;
+
+#[cfg(feature = "ureq")]
+mod ureq;
+
+#[cfg(feature = "ureq")]
+pub use self::ureq::*;
+
+fn into_fee_rate(target: usize, estimates: HashMap<String, f64>) -> Result<FeeRate, Error> {
+    let fee_val = estimates
+        .into_iter()
+        .map(|(k, v)| Ok::<_, std::num::ParseIntError>((k.parse::<usize>()?, v)))
+        .collect::<Result<Vec<_>, _>>()
+        .map_err(|e| Error::Generic(e.to_string()))?
+        .into_iter()
+        .take_while(|(k, _)| k <= &target)
+        .map(|(_, v)| v)
+        .last()
+        .unwrap_or(1.0);
+
+    Ok(FeeRate::from_sat_per_vb(fee_val as f32))
+}
+
+/// Data type used when fetching transaction history from Esplora.
+#[derive(Deserialize)]
+pub struct EsploraGetHistory {
+    txid: Txid,
+    status: EsploraGetHistoryStatus,
+}
+
+#[derive(Deserialize)]
+struct EsploraGetHistoryStatus {
+    block_height: Option<usize>,
+}
+
+/// Errors that can happen during a sync with [`EsploraBlockchain`]
+#[derive(Debug)]
+pub enum EsploraError {
+    /// Error during ureq HTTP request
+    #[cfg(feature = "ureq")]
+    Ureq(::ureq::Error),
+    /// Transport error during the ureq HTTP call
+    #[cfg(feature = "ureq")]
+    UreqTransport(::ureq::Transport),
+    /// Error during reqwest HTTP request
+    #[cfg(feature = "reqwest")]
+    Reqwest(::reqwest::Error),
+    /// HTTP response error
+    HttpResponse(u16),
+    /// IO error during ureq response read
+    Io(io::Error),
+    /// No header found in ureq response
+    NoHeader,
+    /// Invalid number returned
+    Parsing(std::num::ParseIntError),
+    /// Invalid Bitcoin data returned
+    BitcoinEncoding(bitcoin::consensus::encode::Error),
+    /// Invalid Hex data returned
+    Hex(bitcoin::hashes::hex::Error),
+
+    /// Transaction not found
+    TransactionNotFound(Txid),
+    /// Header height not found
+    HeaderHeightNotFound(u32),
+    /// Header hash not found
+    HeaderHashNotFound(BlockHash),
+}
+
+impl fmt::Display for EsploraError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+
+impl std::error::Error for EsploraError {}
+
+#[cfg(feature = "ureq")]
+impl_error!(::ureq::Error, Ureq, EsploraError);
+#[cfg(feature = "ureq")]
+impl_error!(::ureq::Transport, UreqTransport, EsploraError);
+#[cfg(feature = "reqwest")]
+impl_error!(::reqwest::Error, Reqwest, EsploraError);
+impl_error!(io::Error, Io, EsploraError);
+impl_error!(std::num::ParseIntError, Parsing, EsploraError);
+impl_error!(consensus::encode::Error, BitcoinEncoding, EsploraError);
+impl_error!(bitcoin::hashes::hex::Error, Hex, EsploraError);
+
+#[cfg(test)]
+#[cfg(feature = "test-esplora")]
+crate::bdk_blockchain_tests! {
+    fn test_instance(test_client: &TestClient) -> EsploraBlockchain {
+        EsploraBlockchain::new(&format!("http://{}",test_client.electrsd.esplora_url.as_ref().unwrap()), 20)
+    }
+}
--- a/src/blockchain/esplora/reqwest.rs
+++ b/src/blockchain/esplora/reqwest.rs
@@ -9,38 +9,25 @@
 // You may not use this file except in accordance with one or both of these
 // licenses.

-//! Esplora
-//!
-//! This module defines a [`Blockchain`] struct that can query an Esplora backend
-//! populate the wallet's [database](crate::database::Database) by
-//!
-//! ## Example
-//!
-//! ```no_run
-//! # use bdk::blockchain::esplora::EsploraBlockchain;
-//! let blockchain = EsploraBlockchain::new("https://blockstream.info/testnet/api", None);
-//! # Ok::<(), bdk::Error>(())
-//! ```
+//! Esplora by way of `reqwest` HTTP client.

 use std::collections::{HashMap, HashSet};
-use std::fmt;

-use futures::stream::{self, FuturesOrdered, StreamExt, TryStreamExt};
+use bitcoin::consensus::{deserialize, serialize};
+use bitcoin::hashes::hex::{FromHex, ToHex};
+use bitcoin::hashes::{sha256, Hash};
+use bitcoin::{BlockHeader, Script, Transaction, Txid};

 #[allow(unused_imports)]
 use log::{debug, error, info, trace};

-use serde::Deserialize;
+use futures::stream::{self, FuturesOrdered, StreamExt, TryStreamExt};

-use reqwest::{Client, StatusCode};
+use ::reqwest::{Client, StatusCode};

-use bitcoin::consensus::{self, deserialize, serialize};
-use bitcoin::hashes::hex::{FromHex, ToHex};
-use bitcoin::hashes::{sha256, Hash};
-use bitcoin::{BlockHash, BlockHeader, Script, Transaction, Txid};
-
-use self::utils::{ElectrumLikeSync, ElsGetHistoryRes};
-use super::*;
+use crate::blockchain::esplora::{EsploraError, EsploraGetHistory};
+use crate::blockchain::utils::{ElectrumLikeSync, ElsGetHistoryRes};
+use crate::blockchain::*;
 use crate::database::BatchDatabase;
 use crate::error::Error;
 use crate::wallet::utils::ChunksIterator;
@@ -62,22 +49,37 @@ struct UrlClient {
 /// ## Example
 /// See the [`blockchain::esplora`](crate::blockchain::esplora) module for a usage example.
 #[derive(Debug)]
-pub struct EsploraBlockchain(UrlClient);
+pub struct EsploraBlockchain {
+    url_client: UrlClient,
+    stop_gap: usize,
+}

 impl std::convert::From<UrlClient> for EsploraBlockchain {
    fn from(url_client: UrlClient) -> Self {
-        EsploraBlockchain(url_client)
+        EsploraBlockchain {
+            url_client,
+            stop_gap: 20,
+        }
    }
 }

 impl EsploraBlockchain {
-    /// Create a new instance of the client from a base URL
-    pub fn new(base_url: &str, concurrency: Option<u8>) -> Self {
-        EsploraBlockchain(UrlClient {
-            url: base_url.to_string(),
-            client: Client::new(),
-            concurrency: concurrency.unwrap_or(DEFAULT_CONCURRENT_REQUESTS),
-        })
+    /// Create a new instance of the client from a base URL and `stop_gap`.
+    pub fn new(base_url: &str, stop_gap: usize) -> Self {
+        EsploraBlockchain {
+            url_client: UrlClient {
+                url: base_url.to_string(),
+                client: Client::new(),
+                concurrency: DEFAULT_CONCURRENT_REQUESTS,
+            },
+            stop_gap,
+        }
+    }
+
+    /// Set the concurrency to use when doing batch queries against the Esplora instance.
+    pub fn with_concurrency(mut self, concurrency: u8) -> Self {
+        self.url_client.concurrency = concurrency;
+        self
    }
 }

@@ -95,42 +97,29 @@ impl Blockchain for EsploraBlockchain {

    fn setup<D: BatchDatabase, P: Progress>(
        &self,
-        stop_gap: Option<usize>,
        database: &mut D,
        progress_update: P,
    ) -> Result<(), Error> {
        maybe_await!(self
-            .0
-            .electrum_like_setup(stop_gap, database, progress_update))
+            .url_client
+            .electrum_like_setup(self.stop_gap, database, progress_update))
    }

    fn get_tx(&self, txid: &Txid) -> Result<Option<Transaction>, Error> {
-        Ok(await_or_block!(self.0._get_tx(txid))?)
+        Ok(await_or_block!(self.url_client._get_tx(txid))?)
    }

    fn broadcast(&self, tx: &Transaction) -> Result<(), Error> {
-        Ok(await_or_block!(self.0._broadcast(tx))?)
+        Ok(await_or_block!(self.url_client._broadcast(tx))?)
    }

    fn get_height(&self) -> Result<u32, Error> {
-        Ok(await_or_block!(self.0._get_height())?)
+        Ok(await_or_block!(self.url_client._get_height())?)
    }

    fn estimate_fee(&self, target: usize) -> Result<FeeRate, Error> {
-        let estimates = await_or_block!(self.0._get_fee_estimates())?;
-
-        let fee_val = estimates
-            .into_iter()
-            .map(|(k, v)| Ok::<_, std::num::ParseIntError>((k.parse::<usize>()?, v)))
-            .collect::<Result<Vec<_>, _>>()
-            .map_err(|e| Error::Generic(e.to_string()))?
-            .into_iter()
-            .take_while(|(k, _)| k <= &target)
-            .map(|(_, v)| v)
-            .last()
-            .unwrap_or(1.0);
-
-        Ok(FeeRate::from_sat_per_vb(fee_val as f32))
+        let estimates = await_or_block!(self.url_client._get_fee_estimates())?;
+        super::into_fee_rate(target, estimates)
    }
 }

@@ -292,74 +281,51 @@ impl ElectrumLikeSync for UrlClient {
        &self,
        scripts: I,
    ) -> Result<Vec<Vec<ElsGetHistoryRes>>, Error> {
-        let future = async {
-            let mut results = vec![];
-            for chunk in ChunksIterator::new(scripts.into_iter(), self.concurrency as usize) {
-                let mut futs = FuturesOrdered::new();
-                for script in chunk {
-                    futs.push(self._script_get_history(&script));
-                }
-                let partial_results: Vec<Vec<ElsGetHistoryRes>> = futs.try_collect().await?;
-                results.extend(partial_results);
+        let mut results = vec![];
+        for chunk in ChunksIterator::new(scripts.into_iter(), self.concurrency as usize) {
+            let mut futs = FuturesOrdered::new();
+            for script in chunk {
+                futs.push(self._script_get_history(script));
            }
-            Ok(stream::iter(results).collect().await)
-        };
-
-        await_or_block!(future)
+            let partial_results: Vec<Vec<ElsGetHistoryRes>> = await_or_block!(futs.try_collect())?;
+            results.extend(partial_results);
+        }
+        Ok(await_or_block!(stream::iter(results).collect()))
    }

    fn els_batch_transaction_get<'s, I: IntoIterator<Item = &'s Txid>>(
        &self,
        txids: I,
    ) -> Result<Vec<Transaction>, Error> {
-        let future = async {
-            let mut results = vec![];
-            for chunk in ChunksIterator::new(txids.into_iter(), self.concurrency as usize) {
-                let mut futs = FuturesOrdered::new();
-                for txid in chunk {
-                    futs.push(self._get_tx_no_opt(&txid));
-                }
-                let partial_results: Vec<Transaction> = futs.try_collect().await?;
-                results.extend(partial_results);
+        let mut results = vec![];
+        for chunk in ChunksIterator::new(txids.into_iter(), self.concurrency as usize) {
+            let mut futs = FuturesOrdered::new();
+            for txid in chunk {
+                futs.push(self._get_tx_no_opt(txid));
            }
-            Ok(stream::iter(results).collect().await)
-        };
-
-        await_or_block!(future)
+            let partial_results: Vec<Transaction> = await_or_block!(futs.try_collect())?;
+            results.extend(partial_results);
+        }
+        Ok(await_or_block!(stream::iter(results).collect()))
    }

    fn els_batch_block_header<I: IntoIterator<Item = u32>>(
        &self,
        heights: I,
    ) -> Result<Vec<BlockHeader>, Error> {
-        let future = async {
-            let mut results = vec![];
-            for chunk in ChunksIterator::new(heights.into_iter(), self.concurrency as usize) {
-                let mut futs = FuturesOrdered::new();
-                for height in chunk {
-                    futs.push(self._get_header(height));
-                }
-                let partial_results: Vec<BlockHeader> = futs.try_collect().await?;
-                results.extend(partial_results);
+        let mut results = vec![];
+        for chunk in ChunksIterator::new(heights.into_iter(), self.concurrency as usize) {
+            let mut futs = FuturesOrdered::new();
+            for height in chunk {
+                futs.push(self._get_header(height));
            }
-            Ok(stream::iter(results).collect().await)
-        };
-
-        await_or_block!(future)
+            let partial_results: Vec<BlockHeader> = await_or_block!(futs.try_collect())?;
+            results.extend(partial_results);
+        }
+        Ok(await_or_block!(stream::iter(results).collect()))
    }
 }

-#[derive(Deserialize)]
-struct EsploraGetHistoryStatus {
-    block_height: Option<usize>,
-}
-
-#[derive(Deserialize)]
-struct EsploraGetHistory {
-    txid: Txid,
-    status: EsploraGetHistoryStatus,
-}
-
 /// Configuration for an [`EsploraBlockchain`]
 #[derive(Debug, serde::Deserialize, serde::Serialize, Clone, PartialEq)]
 pub struct EsploraBlockchainConfig {
@@ -369,55 +335,18 @@ pub struct EsploraBlockchainConfig {
    pub base_url: String,
    /// Number of parallel requests sent to the esplora service (default: 4)
    pub concurrency: Option<u8>,
+    /// Stop searching addresses for transactions after finding an unused gap of this length.
+    pub stop_gap: usize,
 }

 impl ConfigurableBlockchain for EsploraBlockchain {
    type Config = EsploraBlockchainConfig;

    fn from_config(config: &Self::Config) -> Result<Self, Error> {
-        Ok(EsploraBlockchain::new(
-            config.base_url.as_str(),
-            config.concurrency,
-        ))
-    }
-}
-
-/// Errors that can happen during a sync with [`EsploraBlockchain`]
-#[derive(Debug)]
-pub enum EsploraError {
-    /// Error with the HTTP call
-    Reqwest(reqwest::Error),
-    /// Invalid number returned
-    Parsing(std::num::ParseIntError),
-    /// Invalid Bitcoin data returned
-    BitcoinEncoding(bitcoin::consensus::encode::Error),
-    /// Invalid Hex data returned
-    Hex(bitcoin::hashes::hex::Error),
-
-    /// Transaction not found
-    TransactionNotFound(Txid),
-    /// Header height not found
-    HeaderHeightNotFound(u32),
-    /// Header hash not found
-    HeaderHashNotFound(BlockHash),
-}
-
-impl fmt::Display for EsploraError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{:?}", self)
-    }
-}
-
-impl std::error::Error for EsploraError {}
-
-impl_error!(reqwest::Error, Reqwest, EsploraError);
-impl_error!(std::num::ParseIntError, Parsing, EsploraError);
-impl_error!(consensus::encode::Error, BitcoinEncoding, EsploraError);
-impl_error!(bitcoin::hashes::hex::Error, Hex, EsploraError);
-
-#[cfg(feature = "test-blockchains")]
-crate::bdk_blockchain_tests! {
-    fn test_instance() -> EsploraBlockchain {
-        EsploraBlockchain::new(std::env::var("BDK_ESPLORA_URL").unwrap_or("127.0.0.1:3002".into()).as_str(), None)
+        let mut blockchain = EsploraBlockchain::new(config.base_url.as_str(), config.stop_gap);
+        if let Some(concurrency) = config.concurrency {
+            blockchain.url_client.concurrency = concurrency;
+        };
+        Ok(blockchain)
    }
 }
--- a/src/blockchain/esplora/ureq.rs
+++ b/src/blockchain/esplora/ureq.rs
@@ -0,0 +1,379 @@
+// 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.
+
+//! Esplora by way of `ureq` HTTP client.
+
+use std::collections::{HashMap, HashSet};
+use std::io;
+use std::io::Read;
+use std::time::Duration;
+
+#[allow(unused_imports)]
+use log::{debug, error, info, trace};
+
+use ureq::{Agent, Response};
+
+use bitcoin::consensus::{deserialize, serialize};
+use bitcoin::hashes::hex::{FromHex, ToHex};
+use bitcoin::hashes::{sha256, Hash};
+use bitcoin::{BlockHeader, Script, Transaction, Txid};
+
+use crate::blockchain::esplora::{EsploraError, EsploraGetHistory};
+use crate::blockchain::utils::{ElectrumLikeSync, ElsGetHistoryRes};
+use crate::blockchain::*;
+use crate::database::BatchDatabase;
+use crate::error::Error;
+use crate::FeeRate;
+
+#[derive(Debug)]
+struct UrlClient {
+    url: String,
+    agent: Agent,
+}
+
+/// Structure that implements the logic to sync with Esplora
+///
+/// ## Example
+/// See the [`blockchain::esplora`](crate::blockchain::esplora) module for a usage example.
+#[derive(Debug)]
+pub struct EsploraBlockchain {
+    url_client: UrlClient,
+    stop_gap: usize,
+}
+
+impl std::convert::From<UrlClient> for EsploraBlockchain {
+    fn from(url_client: UrlClient) -> Self {
+        EsploraBlockchain {
+            url_client,
+            stop_gap: 20,
+        }
+    }
+}
+
+impl EsploraBlockchain {
+    /// Create a new instance of the client from a base URL and `stop_gap`.
+    pub fn new(base_url: &str, stop_gap: usize) -> Self {
+        EsploraBlockchain {
+            url_client: UrlClient {
+                url: base_url.to_string(),
+                agent: Agent::new(),
+            },
+            stop_gap,
+        }
+    }
+
+    /// Set the inner `ureq` agent.
+    pub fn with_agent(mut self, agent: Agent) -> Self {
+        self.url_client.agent = agent;
+        self
+    }
+}
+
+impl Blockchain for EsploraBlockchain {
+    fn get_capabilities(&self) -> HashSet<Capability> {
+        vec![
+            Capability::FullHistory,
+            Capability::GetAnyTx,
+            Capability::AccurateFees,
+        ]
+        .into_iter()
+        .collect()
+    }
+
+    fn setup<D: BatchDatabase, P: Progress>(
+        &self,
+        database: &mut D,
+        progress_update: P,
+    ) -> Result<(), Error> {
+        self.url_client
+            .electrum_like_setup(self.stop_gap, database, progress_update)
+    }
+
+    fn get_tx(&self, txid: &Txid) -> Result<Option<Transaction>, Error> {
+        Ok(self.url_client._get_tx(txid)?)
+    }
+
+    fn broadcast(&self, tx: &Transaction) -> Result<(), Error> {
+        let _txid = self.url_client._broadcast(tx)?;
+        Ok(())
+    }
+
+    fn get_height(&self) -> Result<u32, Error> {
+        Ok(self.url_client._get_height()?)
+    }
+
+    fn estimate_fee(&self, target: usize) -> Result<FeeRate, Error> {
+        let estimates = self.url_client._get_fee_estimates()?;
+        super::into_fee_rate(target, estimates)
+    }
+}
+
+impl UrlClient {
+    fn script_to_scripthash(script: &Script) -> String {
+        sha256::Hash::hash(script.as_bytes()).into_inner().to_hex()
+    }
+
+    fn _get_tx(&self, txid: &Txid) -> Result<Option<Transaction>, EsploraError> {
+        let resp = self
+            .agent
+            .get(&format!("{}/tx/{}/raw", self.url, txid))
+            .call();
+
+        match resp {
+            Ok(resp) => Ok(Some(deserialize(&into_bytes(resp)?)?)),
+            Err(ureq::Error::Status(code, _)) => {
+                if is_status_not_found(code) {
+                    return Ok(None);
+                }
+                Err(EsploraError::HttpResponse(code))
+            }
+            Err(e) => Err(EsploraError::Ureq(e)),
+        }
+    }
+
+    fn _get_tx_no_opt(&self, txid: &Txid) -> Result<Transaction, EsploraError> {
+        match self._get_tx(txid) {
+            Ok(Some(tx)) => Ok(tx),
+            Ok(None) => Err(EsploraError::TransactionNotFound(*txid)),
+            Err(e) => Err(e),
+        }
+    }
+
+    fn _get_header(&self, block_height: u32) -> Result<BlockHeader, EsploraError> {
+        let resp = self
+            .agent
+            .get(&format!("{}/block-height/{}", self.url, block_height))
+            .call();
+
+        let bytes = match resp {
+            Ok(resp) => Ok(into_bytes(resp)?),
+            Err(ureq::Error::Status(code, _)) => Err(EsploraError::HttpResponse(code)),
+            Err(e) => Err(EsploraError::Ureq(e)),
+        }?;
+
+        let hash = std::str::from_utf8(&bytes)
+            .map_err(|_| EsploraError::HeaderHeightNotFound(block_height))?;
+
+        let resp = self
+            .agent
+            .get(&format!("{}/block/{}/header", self.url, hash))
+            .call();
+
+        match resp {
+            Ok(resp) => Ok(deserialize(&Vec::from_hex(&resp.into_string()?)?)?),
+            Err(ureq::Error::Status(code, _)) => Err(EsploraError::HttpResponse(code)),
+            Err(e) => Err(EsploraError::Ureq(e)),
+        }
+    }
+
+    fn _broadcast(&self, transaction: &Transaction) -> Result<(), EsploraError> {
+        let resp = self
+            .agent
+            .post(&format!("{}/tx", self.url))
+            .send_string(&serialize(transaction).to_hex());
+
+        match resp {
+            Ok(_) => Ok(()), // We do not return the txid?
+            Err(ureq::Error::Status(code, _)) => Err(EsploraError::HttpResponse(code)),
+            Err(e) => Err(EsploraError::Ureq(e)),
+        }
+    }
+
+    fn _get_height(&self) -> Result<u32, EsploraError> {
+        let resp = self
+            .agent
+            .get(&format!("{}/blocks/tip/height", self.url))
+            .call();
+
+        match resp {
+            Ok(resp) => Ok(resp.into_string()?.parse()?),
+            Err(ureq::Error::Status(code, _)) => Err(EsploraError::HttpResponse(code)),
+            Err(e) => Err(EsploraError::Ureq(e)),
+        }
+    }
+
+    fn _script_get_history(&self, script: &Script) -> Result<Vec<ElsGetHistoryRes>, EsploraError> {
+        let mut result = Vec::new();
+        let scripthash = Self::script_to_scripthash(script);
+
+        // Add the unconfirmed transactions first
+
+        let resp = self
+            .agent
+            .get(&format!(
+                "{}/scripthash/{}/txs/mempool",
+                self.url, scripthash
+            ))
+            .call();
+
+        let v = match resp {
+            Ok(resp) => {
+                let v: Vec<EsploraGetHistory> = resp.into_json()?;
+                Ok(v)
+            }
+            Err(ureq::Error::Status(code, _)) => Err(EsploraError::HttpResponse(code)),
+            Err(e) => Err(EsploraError::Ureq(e)),
+        }?;
+
+        result.extend(v.into_iter().map(|x| ElsGetHistoryRes {
+            tx_hash: x.txid,
+            height: x.status.block_height.unwrap_or(0) as i32,
+        }));
+
+        debug!(
+            "Found {} mempool txs for {} - {:?}",
+            result.len(),
+            scripthash,
+            script
+        );
+
+        // Then go through all the pages of confirmed transactions
+        let mut last_txid = String::new();
+        loop {
+            let resp = self
+                .agent
+                .get(&format!(
+                    "{}/scripthash/{}/txs/chain/{}",
+                    self.url, scripthash, last_txid
+                ))
+                .call();
+
+            let v = match resp {
+                Ok(resp) => {
+                    let v: Vec<EsploraGetHistory> = resp.into_json()?;
+                    Ok(v)
+                }
+                Err(ureq::Error::Status(code, _)) => Err(EsploraError::HttpResponse(code)),
+                Err(e) => Err(EsploraError::Ureq(e)),
+            }?;
+
+            let len = v.len();
+            if let Some(elem) = v.last() {
+                last_txid = elem.txid.to_hex();
+            }
+
+            debug!("... adding {} confirmed transactions", len);
+
+            result.extend(v.into_iter().map(|x| ElsGetHistoryRes {
+                tx_hash: x.txid,
+                height: x.status.block_height.unwrap_or(0) as i32,
+            }));
+
+            if len < 25 {
+                break;
+            }
+        }
+
+        Ok(result)
+    }
+
+    fn _get_fee_estimates(&self) -> Result<HashMap<String, f64>, EsploraError> {
+        let resp = self
+            .agent
+            .get(&format!("{}/fee-estimates", self.url,))
+            .call();
+
+        let map = match resp {
+            Ok(resp) => {
+                let map: HashMap<String, f64> = resp.into_json()?;
+                Ok(map)
+            }
+            Err(ureq::Error::Status(code, _)) => Err(EsploraError::HttpResponse(code)),
+            Err(e) => Err(EsploraError::Ureq(e)),
+        }?;
+
+        Ok(map)
+    }
+}
+
+fn is_status_not_found(status: u16) -> bool {
+    status == 404
+}
+
+fn into_bytes(resp: Response) -> Result<Vec<u8>, io::Error> {
+    const BYTES_LIMIT: usize = 10 * 1_024 * 1_024;
+
+    let mut buf: Vec<u8> = vec![];
+    resp.into_reader()
+        .take((BYTES_LIMIT + 1) as u64)
+        .read_to_end(&mut buf)?;
+    if buf.len() > BYTES_LIMIT {
+        return Err(io::Error::new(
+            io::ErrorKind::Other,
+            "response too big for into_bytes",
+        ));
+    }
+
+    Ok(buf)
+}
+
+impl ElectrumLikeSync for UrlClient {
+    fn els_batch_script_get_history<'s, I: IntoIterator<Item = &'s Script>>(
+        &self,
+        scripts: I,
+    ) -> Result<Vec<Vec<ElsGetHistoryRes>>, Error> {
+        let mut results = vec![];
+        for script in scripts.into_iter() {
+            let v = self._script_get_history(script)?;
+            results.push(v);
+        }
+        Ok(results)
+    }
+
+    fn els_batch_transaction_get<'s, I: IntoIterator<Item = &'s Txid>>(
+        &self,
+        txids: I,
+    ) -> Result<Vec<Transaction>, Error> {
+        let mut results = vec![];
+        for txid in txids.into_iter() {
+            let tx = self._get_tx_no_opt(txid)?;
+            results.push(tx);
+        }
+        Ok(results)
+    }
+
+    fn els_batch_block_header<I: IntoIterator<Item = u32>>(
+        &self,
+        heights: I,
+    ) -> Result<Vec<BlockHeader>, Error> {
+        let mut results = vec![];
+        for height in heights.into_iter() {
+            let header = self._get_header(height)?;
+            results.push(header);
+        }
+        Ok(results)
+    }
+}
+
+/// Configuration for an [`EsploraBlockchain`]
+#[derive(Debug, serde::Deserialize, serde::Serialize, Clone, PartialEq)]
+pub struct EsploraBlockchainConfig {
+    /// Base URL of the esplora service eg. `https://blockstream.info/api/`
+    pub base_url: String,
+    /// Socket read timeout.
+    pub timeout_read: u64,
+    /// Socket write timeout.
+    pub timeout_write: u64,
+    /// Stop searching addresses for transactions after finding an unused gap of this length.
+    pub stop_gap: usize,
+}
+
+impl ConfigurableBlockchain for EsploraBlockchain {
+    type Config = EsploraBlockchainConfig;
+
+    fn from_config(config: &Self::Config) -> Result<Self, Error> {
+        let agent: Agent = ureq::AgentBuilder::new()
+            .timeout_read(Duration::from_secs(config.timeout_read))
+            .timeout_write(Duration::from_secs(config.timeout_write))
+            .build();
+        Ok(EsploraBlockchain::new(config.base_url.as_str(), config.stop_gap).with_agent(agent))
+    }
+}
--- a/src/blockchain/mod.rs
+++ b/src/blockchain/mod.rs
@@ -30,9 +30,19 @@ use crate::FeeRate;
 #[cfg(any(feature = "electrum", feature = "esplora"))]
 pub(crate) mod utils;

-#[cfg(any(feature = "electrum", feature = "esplora", feature = "compact_filters"))]
+#[cfg(any(
+    feature = "electrum",
+    feature = "esplora",
+    feature = "compact_filters",
+    feature = "rpc"
+))]
 pub mod any;
-#[cfg(any(feature = "electrum", feature = "esplora", feature = "compact_filters"))]
+#[cfg(any(
+    feature = "electrum",
+    feature = "esplora",
+    feature = "compact_filters",
+    feature = "rpc"
+))]
 pub use any::{AnyBlockchain, AnyBlockchainConfig};

 #[cfg(feature = "electrum")]
@@ -44,6 +54,7 @@ pub use self::electrum::ElectrumBlockchain;
 pub use self::electrum::ElectrumBlockchainConfig;

 #[cfg(feature = "rpc")]
+#[cfg_attr(docsrs, doc(cfg(feature = "rpc")))]
 pub mod rpc;
 #[cfg(feature = "rpc")]
 pub use self::rpc::RpcBlockchain;
@@ -92,7 +103,6 @@ pub trait Blockchain {
    /// [`Blockchain::sync`] defaults to calling this internally if not overridden.
    fn setup<D: BatchDatabase, P: 'static + Progress>(
        &self,
-        stop_gap: Option<usize>,
        database: &mut D,
        progress_update: P,
    ) -> Result<(), Error>;
@@ -117,11 +127,10 @@ pub trait Blockchain {
    /// [`BatchOperations::del_utxo`]: crate::database::BatchOperations::del_utxo
    fn sync<D: BatchDatabase, P: 'static + Progress>(
        &self,
-        stop_gap: Option<usize>,
        database: &mut D,
        progress_update: P,
    ) -> Result<(), Error> {
-        maybe_await!(self.setup(stop_gap, database, progress_update))
+        maybe_await!(self.setup(database, progress_update))
    }

    /// Fetch a transaction from the blockchain given its txid
@@ -217,20 +226,18 @@ impl<T: Blockchain> Blockchain for Arc<T> {

    fn setup<D: BatchDatabase, P: 'static + Progress>(
        &self,
-        stop_gap: Option<usize>,
        database: &mut D,
        progress_update: P,
    ) -> Result<(), Error> {
-        maybe_await!(self.deref().setup(stop_gap, database, progress_update))
+        maybe_await!(self.deref().setup(database, progress_update))
    }

    fn sync<D: BatchDatabase, P: 'static + Progress>(
        &self,
-        stop_gap: Option<usize>,
        database: &mut D,
        progress_update: P,
    ) -> Result<(), Error> {
-        maybe_await!(self.deref().sync(stop_gap, database, progress_update))
+        maybe_await!(self.deref().sync(database, progress_update))
    }

    fn get_tx(&self, txid: &Txid) -> Result<Option<Transaction>, Error> {
--- a/src/blockchain/rpc.rs
+++ b/src/blockchain/rpc.rs
@@ -18,10 +18,12 @@
 //! ## Example
 //!
 //! ```no_run
-//! # use bdk::blockchain::{RpcConfig, RpcBlockchain, ConfigurableBlockchain};
+//! # use bdk::blockchain::{RpcConfig, RpcBlockchain, ConfigurableBlockchain, rpc::Auth};
 //! let config = RpcConfig {
 //!     url: "127.0.0.1:18332".to_string(),
-//!     auth: bitcoincore_rpc::Auth::CookieFile("/home/user/.bitcoin/.cookie".into()),
+//!     auth: Auth::Cookie {
+//!         file: "/home/user/.bitcoin/.cookie".into(),
+//!     },
 //!     network: bdk::bitcoin::Network::Testnet,
 //!     wallet_name: "wallet_name".to_string(),
 //!     skip_blocks: None,
@@ -36,15 +38,17 @@ use crate::database::{BatchDatabase, DatabaseUtils};
 use crate::descriptor::{get_checksum, IntoWalletDescriptor};
 use crate::wallet::utils::SecpCtx;
 use crate::{ConfirmationTime, Error, FeeRate, KeychainKind, LocalUtxo, TransactionDetails};
-use bitcoincore_rpc::json::{
+use core_rpc::json::{
    GetAddressInfoResultLabel, ImportMultiOptions, ImportMultiRequest,
    ImportMultiRequestScriptPubkey, ImportMultiRescanSince,
 };
-use bitcoincore_rpc::jsonrpc::serde_json::Value;
-use bitcoincore_rpc::{Auth, Client, RpcApi};
+use core_rpc::jsonrpc::serde_json::Value;
+use core_rpc::Auth as RpcAuth;
+use core_rpc::{Client, RpcApi};
 use log::debug;
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 use std::collections::{HashMap, HashSet};
+use std::path::PathBuf;
 use std::str::FromStr;

 /// The main struct for RPC backend implementing the [crate::blockchain::Blockchain] trait
@@ -64,7 +68,7 @@ pub struct RpcBlockchain {
 }

 /// RpcBlockchain configuration options
-#[derive(Debug)]
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
 pub struct RpcConfig {
    /// The bitcoin node url
    pub url: String,
@@ -78,6 +82,39 @@ pub struct RpcConfig {
    pub skip_blocks: Option<u32>,
 }

+/// This struct is equivalent to [core_rpc::Auth] but it implements [serde::Serialize]
+/// To be removed once upstream equivalent is implementing Serialize (json serialization format
+/// should be the same) https://github.com/rust-bitcoin/rust-bitcoincore-rpc/pull/181
+#[derive(Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+#[serde(untagged)]
+pub enum Auth {
+    /// None authentication
+    None,
+    /// Authentication with username and password, usually [Auth::Cookie] should be preferred
+    UserPass {
+        /// Username
+        username: String,
+        /// Password
+        password: String,
+    },
+    /// Authentication with a cookie file
+    Cookie {
+        /// Cookie file
+        file: PathBuf,
+    },
+}
+
+impl From<Auth> for RpcAuth {
+    fn from(auth: Auth) -> Self {
+        match auth {
+            Auth::None => RpcAuth::None,
+            Auth::UserPass { username, password } => RpcAuth::UserPass(username, password),
+            Auth::Cookie { file } => RpcAuth::CookieFile(file),
+        }
+    }
+}
+
 impl RpcBlockchain {
    fn get_node_synced_height(&self) -> Result<u32, Error> {
        let info = self.client.get_address_info(&self._storage_address)?;
@@ -106,7 +143,6 @@ impl Blockchain for RpcBlockchain {

    fn setup<D: BatchDatabase, P: 'static + Progress>(
        &self,
-        stop_gap: Option<usize>,
        database: &mut D,
        progress_update: P,
    ) -> Result<(), Error> {
@@ -150,12 +186,11 @@ impl Blockchain for RpcBlockchain {

        self.set_node_synced_height(current_height)?;

-        self.sync(stop_gap, database, progress_update)
+        self.sync(database, progress_update)
    }

    fn sync<D: BatchDatabase, P: 'static + Progress>(
        &self,
-        _stop_gap: Option<usize>,
        db: &mut D,
        _progress_update: P,
    ) -> Result<(), Error> {
@@ -322,7 +357,7 @@ impl ConfigurableBlockchain for RpcBlockchain {
        let wallet_url = format!("{}/wallet/{}", config.url, &wallet_name);
        debug!("connecting to {} auth:{:?}", wallet_url, config.auth);

-        let client = Client::new(wallet_url, config.auth.clone())?;
+        let client = Client::new(wallet_url.as_str(), config.auth.clone().into())?;
        let loaded_wallets = client.list_wallets()?;
        if loaded_wallets.contains(&wallet_name) {
            debug!("wallet already loaded {:?}", wallet_name);
@@ -422,27 +457,14 @@ fn list_wallet_dir(client: &Client) -> Result<Vec<String>, Error> {
    Ok(result.wallets.into_iter().map(|n| n.name).collect())
 }

-#[cfg(feature = "test-blockchains")]
+#[cfg(test)]
+#[cfg(feature = "test-rpc")]
 crate::bdk_blockchain_tests! {

-    fn test_instance() -> RpcBlockchain {
-        let url = std::env::var("BDK_RPC_URL").unwrap_or_else(|_| "127.0.0.1:18443".to_string());
-        let url = format!("http://{}", url);
-
-        // TODO same code in `fn get_auth` in testutils, make it public there
-        let auth = match std::env::var("BDK_RPC_AUTH").as_ref().map(String::as_ref) {
-            Ok("USER_PASS") => Auth::UserPass(
-                std::env::var("BDK_RPC_USER").unwrap(),
-                std::env::var("BDK_RPC_PASS").unwrap(),
-            ),
-            _ => Auth::CookieFile(std::path::PathBuf::from(
-                std::env::var("BDK_RPC_COOKIEFILE")
-                    .unwrap_or_else(|_| "/home/user/.bitcoin/regtest/.cookie".to_string()),
-            )),
-        };
+    fn test_instance(test_client: &TestClient) -> RpcBlockchain {
        let config = RpcConfig {
-            url,
-            auth,
+            url: test_client.bitcoind.rpc_url(),
+            auth: Auth::Cookie { file: test_client.bitcoind.params.cookie_file.clone() },
            network: Network::Regtest,
            wallet_name: format!("client-wallet-test-{:?}", std::time::SystemTime::now() ),
            skip_blocks: None,
@@ -450,227 +472,3 @@ crate::bdk_blockchain_tests! {
        RpcBlockchain::from_config(&config).unwrap()
    }
 }
-
-#[cfg(feature = "test-rpc")]
-#[cfg(test)]
-mod test {
-    use super::{RpcBlockchain, RpcConfig};
-    use crate::bitcoin::consensus::deserialize;
-    use crate::bitcoin::{Address, Amount, Network, Transaction};
-    use crate::blockchain::rpc::wallet_name_from_descriptor;
-    use crate::blockchain::{noop_progress, Blockchain, Capability, ConfigurableBlockchain};
-    use crate::database::MemoryDatabase;
-    use crate::wallet::AddressIndex;
-    use crate::Wallet;
-    use bitcoin::secp256k1::Secp256k1;
-    use bitcoin::Txid;
-    use bitcoincore_rpc::json::CreateRawTransactionInput;
-    use bitcoincore_rpc::RawTx;
-    use bitcoincore_rpc::{Auth, RpcApi};
-    use bitcoind::BitcoinD;
-    use std::collections::HashMap;
-
-    fn create_rpc(
-        bitcoind: &BitcoinD,
-        desc: &str,
-        network: Network,
-    ) -> Result<RpcBlockchain, crate::Error> {
-        let secp = Secp256k1::new();
-        let wallet_name = wallet_name_from_descriptor(desc, None, network, &secp).unwrap();
-
-        let config = RpcConfig {
-            url: bitcoind.rpc_url(),
-            auth: Auth::CookieFile(bitcoind.config.cookie_file.clone()),
-            network,
-            wallet_name,
-            skip_blocks: None,
-        };
-        RpcBlockchain::from_config(&config)
-    }
-    fn create_bitcoind(args: Vec<String>) -> BitcoinD {
-        let exe = std::env::var("BITCOIND_EXE").unwrap();
-        bitcoind::BitcoinD::with_args(exe, args, false, bitcoind::P2P::No).unwrap()
-    }
-
-    const DESCRIPTOR_PUB: &'static str = "wpkh(tpubD6NzVbkrYhZ4X2yy78HWrr1M9NT8dKeWfzNiQqDdMqqa9UmmGztGGz6TaLFGsLfdft5iu32gxq1T4eMNxExNNWzVCpf9Y6JZi5TnqoC9wJq/*)";
-    const DESCRIPTOR_PRIV: &'static str = "wpkh(tprv8ZgxMBicQKsPdZxBDUcvTSMEaLwCTzTc6gmw8KBKwa3BJzWzec4g6VUbQBHJcutDH6mMEmBeVyN27H1NF3Nu8isZ1Sts4SufWyfLE6Mf1MB/*)";
-
-    #[test]
-    fn test_rpc_wallet_setup() {
-        env_logger::try_init().unwrap();
-        let bitcoind = create_bitcoind(vec![]);
-        let node_address = bitcoind.client.get_new_address(None, None).unwrap();
-        let blockchain = create_rpc(&bitcoind, DESCRIPTOR_PUB, Network::Regtest).unwrap();
-        let db = MemoryDatabase::new();
-        let wallet = Wallet::new(DESCRIPTOR_PRIV, None, Network::Regtest, db, blockchain).unwrap();
-
-        wallet.sync(noop_progress(), None).unwrap();
-        generate(&bitcoind, 101);
-        wallet.sync(noop_progress(), None).unwrap();
-        let address = wallet.get_address(AddressIndex::New).unwrap();
-        let expected_address = "bcrt1q8dyvgt4vhr8ald4xuwewcxhdjha9a5k78wxm5t";
-        assert_eq!(expected_address, address.to_string());
-        send_to_address(&bitcoind, &address, 100_000);
-        wallet.sync(noop_progress(), None).unwrap();
-        assert_eq!(wallet.get_balance().unwrap(), 100_000);
-
-        let mut builder = wallet.build_tx();
-        builder.add_recipient(node_address.script_pubkey(), 50_000);
-        let (mut psbt, details) = builder.finish().unwrap();
-        let finalized = wallet.sign(&mut psbt, Default::default()).unwrap();
-        assert!(finalized, "Cannot finalize transaction");
-        let tx = psbt.extract_tx();
-        wallet.broadcast(tx).unwrap();
-        wallet.sync(noop_progress(), None).unwrap();
-        assert_eq!(
-            wallet.get_balance().unwrap(),
-            100_000 - 50_000 - details.fee.unwrap_or(0)
-        );
-        drop(wallet);
-
-        // test skip_blocks
-        generate(&bitcoind, 5);
-        let config = RpcConfig {
-            url: bitcoind.rpc_url(),
-            auth: Auth::CookieFile(bitcoind.config.cookie_file.clone()),
-            network: Network::Regtest,
-            wallet_name: "another-name".to_string(),
-            skip_blocks: Some(103),
-        };
-        let blockchain_skip = RpcBlockchain::from_config(&config).unwrap();
-        let db = MemoryDatabase::new();
-        let wallet_skip =
-            Wallet::new(DESCRIPTOR_PRIV, None, Network::Regtest, db, blockchain_skip).unwrap();
-        wallet_skip.sync(noop_progress(), None).unwrap();
-        send_to_address(&bitcoind, &address, 100_000);
-        wallet_skip.sync(noop_progress(), None).unwrap();
-        assert_eq!(wallet_skip.get_balance().unwrap(), 100_000);
-    }
-
-    #[test]
-    fn test_rpc_from_config() {
-        let bitcoind = create_bitcoind(vec![]);
-        let blockchain = create_rpc(&bitcoind, DESCRIPTOR_PUB, Network::Regtest);
-        assert!(blockchain.is_ok());
-        let blockchain = create_rpc(&bitcoind, DESCRIPTOR_PUB, Network::Testnet);
-        assert!(blockchain.is_err(), "wrong network doesn't error");
-    }
-
-    #[test]
-    fn test_rpc_capabilities_get_tx() {
-        let bitcoind = create_bitcoind(vec![]);
-        let rpc = create_rpc(&bitcoind, DESCRIPTOR_PUB, Network::Regtest).unwrap();
-        let capabilities = rpc.get_capabilities();
-        assert!(capabilities.contains(&Capability::FullHistory) && capabilities.len() == 1);
-        let bitcoind_indexed = create_bitcoind(vec!["-txindex".to_string()]);
-        let rpc_indexed = create_rpc(&bitcoind_indexed, DESCRIPTOR_PUB, Network::Regtest).unwrap();
-        assert_eq!(rpc_indexed.get_capabilities().len(), 3);
-        let address = generate(&bitcoind_indexed, 101);
-        let txid = send_to_address(&bitcoind_indexed, &address, 100_000);
-        assert!(rpc_indexed.get_tx(&txid).unwrap().is_some());
-        assert!(rpc.get_tx(&txid).is_err());
-    }
-
-    #[test]
-    fn test_rpc_estimate_fee_get_height() {
-        let bitcoind = create_bitcoind(vec![]);
-        let rpc = create_rpc(&bitcoind, DESCRIPTOR_PUB, Network::Regtest).unwrap();
-        let result = rpc.estimate_fee(2);
-        assert!(result.is_err());
-        let address = generate(&bitcoind, 100);
-        // create enough tx so that core give some fee estimation
-        for _ in 0..15 {
-            let _ = bitcoind.client.generate_to_address(1, &address).unwrap();
-            for _ in 0..2 {
-                send_to_address(&bitcoind, &address, 100_000);
-            }
-        }
-        let result = rpc.estimate_fee(2);
-        assert!(result.is_ok());
-        assert_eq!(rpc.get_height().unwrap(), 115);
-    }
-
-    #[test]
-    fn test_rpc_node_synced_height() {
-        let bitcoind = create_bitcoind(vec![]);
-        let rpc = create_rpc(&bitcoind, DESCRIPTOR_PUB, Network::Regtest).unwrap();
-        let synced_height = rpc.get_node_synced_height().unwrap();
-
-        assert_eq!(synced_height, 0);
-        rpc.set_node_synced_height(1).unwrap();
-
-        let synced_height = rpc.get_node_synced_height().unwrap();
-        assert_eq!(synced_height, 1);
-    }
-
-    #[test]
-    fn test_rpc_broadcast() {
-        let bitcoind = create_bitcoind(vec![]);
-        let rpc = create_rpc(&bitcoind, DESCRIPTOR_PUB, Network::Regtest).unwrap();
-        let address = generate(&bitcoind, 101);
-        let utxo = bitcoind
-            .client
-            .list_unspent(None, None, None, None, None)
-            .unwrap();
-        let input = CreateRawTransactionInput {
-            txid: utxo[0].txid,
-            vout: utxo[0].vout,
-            sequence: None,
-        };
-
-        let out: HashMap<_, _> = vec![(
-            address.to_string(),
-            utxo[0].amount - Amount::from_sat(100_000),
-        )]
-        .into_iter()
-        .collect();
-        let tx = bitcoind
-            .client
-            .create_raw_transaction(&[input], &out, None, None)
-            .unwrap();
-        let signed_tx = bitcoind
-            .client
-            .sign_raw_transaction_with_wallet(tx.raw_hex(), None, None)
-            .unwrap();
-        let parsed_tx: Transaction = deserialize(&signed_tx.hex).unwrap();
-        rpc.broadcast(&parsed_tx).unwrap();
-        assert!(bitcoind
-            .client
-            .get_raw_mempool()
-            .unwrap()
-            .contains(&tx.txid()));
-    }
-
-    #[test]
-    fn test_rpc_wallet_name() {
-        let secp = Secp256k1::new();
-        let name =
-            wallet_name_from_descriptor(DESCRIPTOR_PUB, None, Network::Regtest, &secp).unwrap();
-        assert_eq!("tmg7aqay", name);
-    }
-
-    fn generate(bitcoind: &BitcoinD, blocks: u64) -> Address {
-        let address = bitcoind.client.get_new_address(None, None).unwrap();
-        bitcoind
-            .client
-            .generate_to_address(blocks, &address)
-            .unwrap();
-        address
-    }
-
-    fn send_to_address(bitcoind: &BitcoinD, address: &Address, amount: u64) -> Txid {
-        bitcoind
-            .client
-            .send_to_address(
-                &address,
-                Amount::from_sat(amount),
-                None,
-                None,
-                None,
-                None,
-                None,
-                None,
-            )
-            .unwrap()
-    }
-}
--- a/src/blockchain/utils.rs
+++ b/src/blockchain/utils.rs
@@ -53,7 +53,7 @@ pub trait ElectrumLikeSync {

    fn electrum_like_setup<D: BatchDatabase, P: Progress>(
        &self,
-        stop_gap: Option<usize>,
+        stop_gap: usize,
        db: &mut D,
        _progress_update: P,
    ) -> Result<(), Error> {
@@ -61,7 +61,6 @@ pub trait ElectrumLikeSync {
        let start = Instant::new();
        debug!("start setup");

-        let stop_gap = stop_gap.unwrap_or(20);
        let chunk_size = stop_gap;

        let mut history_txs_id = HashSet::new();
@@ -370,7 +369,7 @@ fn save_transaction_details_and_utxos<D: BatchDatabase>(
 }

 /// returns utxo dependency as the inputs needed for the utxo to exist
-/// `tx_raw_in_db` must contains utxo's generating txs or errors witt [crate::Error::TransactionNotFound]
+/// `tx_raw_in_db` must contains utxo's generating txs or errors with [crate::Error::TransactionNotFound]
 fn utxos_deps<D: BatchDatabase>(
    db: &mut D,
    tx_raw_in_db: &HashMap<Txid, Transaction>,
--- a/src/database/any.rs
+++ b/src/database/any.rs
@@ -233,6 +233,10 @@ impl Database for AnyDatabase {
    fn increment_last_index(&mut self, keychain: KeychainKind) -> Result<u32, Error> {
        impl_inner_method!(AnyDatabase, self, increment_last_index, keychain)
    }
+
+    fn flush(&mut self) -> Result<(), Error> {
+        impl_inner_method!(AnyDatabase, self, flush)
+    }
 }

 impl BatchOperations for AnyBatch {
--- a/src/database/keyvalue.rs
+++ b/src/database/keyvalue.rs
@@ -367,6 +367,10 @@ impl Database for Tree {
            Ok(val)
        })
    }
+
+    fn flush(&mut self) -> Result<(), Error> {
+        Ok(Tree::flush(self).map(|_| ())?)
+    }
 }

 impl BatchDatabase for Tree {
@@ -383,6 +387,7 @@ impl BatchDatabase for Tree {

 #[cfg(test)]
 mod test {
+    use lazy_static::lazy_static;
    use std::sync::{Arc, Condvar, Mutex, Once};
    use std::time::{SystemTime, UNIX_EPOCH};

--- a/src/database/memory.rs
+++ b/src/database/memory.rs
@@ -419,6 +419,10 @@ impl Database for MemoryDatabase {

        Ok(*value)
    }
+
+    fn flush(&mut self) -> Result<(), Error> {
+        Ok(())
+    }
 }

 impl BatchDatabase for MemoryDatabase {
--- a/src/database/mod.rs
+++ b/src/database/mod.rs
@@ -134,6 +134,9 @@ pub trait Database: BatchOperations {
    ///
    /// It should insert and return `0` if not present in the database
    fn increment_last_index(&mut self, keychain: KeychainKind) -> Result<u32, Error>;
+
+    /// Force changes to be written to disk
+    fn flush(&mut self) -> Result<(), Error>;
 }

 /// Trait for a database that supports batch operations
--- a/src/error.rs
+++ b/src/error.rs
@@ -24,10 +24,6 @@ pub enum Error {
    Generic(String),
    /// This error is thrown when trying to convert Bare and Public key script to address
    ScriptDoesntHaveAddressForm,
-    /// Found multiple outputs when `single_recipient` option has been specified
-    SingleRecipientMultipleOutputs,
-    /// `single_recipient` option is selected but neither `drain_wallet` nor `manually_selected_only` are
-    SingleRecipientNoInputs,
    /// Cannot build a tx without recipients
    NoRecipients,
    /// `manually_selected_only` option is selected but no utxo has been passed
@@ -134,7 +130,7 @@ pub enum Error {
    Electrum(electrum_client::Error),
    #[cfg(feature = "esplora")]
    /// Esplora client error
-    Esplora(crate::blockchain::esplora::EsploraError),
+    Esplora(Box<crate::blockchain::esplora::EsploraError>),
    #[cfg(feature = "compact_filters")]
    /// Compact filters client error)
    CompactFilters(crate::blockchain::compact_filters::CompactFiltersError),
@@ -143,7 +139,7 @@ pub enum Error {
    Sled(sled::Error),
    #[cfg(feature = "rpc")]
    /// Rpc client error
-    Rpc(bitcoincore_rpc::Error),
+    Rpc(core_rpc::Error),
 }

 impl fmt::Display for Error {
@@ -194,12 +190,10 @@ impl_error!(bitcoin::util::psbt::PsbtParseError, PsbtParse);

 #[cfg(feature = "electrum")]
 impl_error!(electrum_client::Error, Electrum);
-#[cfg(feature = "esplora")]
-impl_error!(crate::blockchain::esplora::EsploraError, Esplora);
 #[cfg(feature = "key-value-db")]
 impl_error!(sled::Error, Sled);
 #[cfg(feature = "rpc")]
-impl_error!(bitcoincore_rpc::Error, Rpc);
+impl_error!(core_rpc::Error, Rpc);

 #[cfg(feature = "compact_filters")]
 impl From<crate::blockchain::compact_filters::CompactFiltersError> for Error {
@@ -220,3 +214,10 @@ impl From<crate::wallet::verify::VerifyError> for Error {
        }
    }
 }
+
+#[cfg(feature = "esplora")]
+impl From<crate::blockchain::esplora::EsploraError> for Error {
+    fn from(other: crate::blockchain::esplora::EsploraError) -> Self {
+        Error::Esplora(Box::new(other))
+    }
+}
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -40,7 +40,7 @@
 //! interact with the bitcoin P2P network.
 //!
 //! ```toml
-//! bdk = "0.9.0"
+//! bdk = "0.11.0"
 //! ```
 #![cfg_attr(
    feature = "electrum",
@@ -205,11 +205,24 @@ extern crate serde;
 #[macro_use]
 extern crate serde_json;

+#[cfg(all(feature = "reqwest", feature = "ureq"))]
+compile_error!("Features reqwest and ureq are mutually exclusive and cannot be enabled together");
+
 #[cfg(all(feature = "async-interface", feature = "electrum"))]
 compile_error!(
    "Features async-interface and electrum are mutually exclusive and cannot be enabled together"
 );

+#[cfg(all(feature = "async-interface", feature = "ureq"))]
+compile_error!(
+    "Features async-interface and ureq are mutually exclusive and cannot be enabled together"
+);
+
+#[cfg(all(feature = "async-interface", feature = "compact_filters"))]
+compile_error!(
+    "Features async-interface and compact_filters are mutually exclusive and cannot be enabled together"
+);
+
 #[cfg(feature = "keys-bip39")]
 extern crate bip39;

@@ -223,24 +236,15 @@ extern crate bdk_macros;
 extern crate lazy_static;

 #[cfg(feature = "rpc")]
-pub extern crate bitcoincore_rpc;
+pub extern crate core_rpc;

 #[cfg(feature = "electrum")]
 pub extern crate electrum_client;

-#[cfg(feature = "esplora")]
-pub extern crate reqwest;
-
 #[cfg(feature = "key-value-db")]
 pub extern crate sled;

 #[allow(unused_imports)]
-#[cfg(test)]
-#[allow(unused_imports)]
-#[cfg(test)]
-#[macro_use]
-pub extern crate serial_test;
-
 #[macro_use]
 pub(crate) mod error;
 pub mod blockchain;
--- a/src/psbt/mod.rs
+++ b/src/psbt/mod.rs
@@ -43,8 +43,8 @@ impl PsbtUtils for Psbt {
 mod test {
    use crate::bitcoin::TxIn;
    use crate::psbt::Psbt;
-    use crate::wallet::test::{get_funded_wallet, get_test_wpkh};
    use crate::wallet::AddressIndex;
+    use crate::wallet::{get_funded_wallet, test::get_test_wpkh};
    use crate::SignOptions;
    use std::str::FromStr;

--- a/src/testutils/blockchain_tests.rs
+++ b/src/testutils/blockchain_tests.rs
@@ -3,41 +3,61 @@ use bitcoin::consensus::encode::{deserialize, serialize};
 use bitcoin::hashes::hex::{FromHex, ToHex};
 use bitcoin::hashes::sha256d;
 use bitcoin::{Address, Amount, Script, Transaction, Txid};
-pub use bitcoincore_rpc::bitcoincore_rpc_json::AddressType;
-pub use bitcoincore_rpc::{Auth, Client as RpcClient, RpcApi};
 use core::str::FromStr;
+pub use core_rpc::core_rpc_json::AddressType;
+pub use core_rpc::{Auth, Client as RpcClient, RpcApi};
+use electrsd::bitcoind::BitcoinD;
+use electrsd::{bitcoind, Conf, ElectrsD};
 pub use electrum_client::{Client as ElectrumClient, ElectrumApi};
 #[allow(unused_imports)]
-use log::{debug, error, info, trace};
+use log::{debug, error, info, log_enabled, trace, Level};
 use std::collections::HashMap;
 use std::env;
 use std::ops::Deref;
-use std::path::PathBuf;
 use std::time::Duration;

 pub struct TestClient {
-    client: RpcClient,
-    electrum: ElectrumClient,
+    pub bitcoind: BitcoinD,
+    pub electrsd: ElectrsD,
 }

 impl TestClient {
-    pub fn new(rpc_host_and_wallet: String, rpc_wallet_name: String) -> Self {
-        let client = RpcClient::new(
-            format!("http://{}/wallet/{}", rpc_host_and_wallet, rpc_wallet_name),
-            get_auth(),
-        )
-        .unwrap();
-        let electrum = ElectrumClient::new(&get_electrum_url()).unwrap();
+    pub fn new(bitcoind_exe: String, electrs_exe: String) -> Self {
+        debug!("launching {} and {}", &bitcoind_exe, &electrs_exe);
+        let conf = bitcoind::Conf {
+            view_stdout: log_enabled!(Level::Debug),
+            ..Default::default()
+        };
+        let bitcoind = BitcoinD::with_conf(bitcoind_exe, &conf).unwrap();

-        TestClient { client, electrum }
+        let http_enabled = cfg!(feature = "test-esplora");
+
+        let conf = Conf {
+            http_enabled,
+            view_stderr: log_enabled!(Level::Debug),
+            ..Default::default()
+        };
+        let electrsd = ElectrsD::with_conf(electrs_exe, &bitcoind, &conf).unwrap();
+
+        let node_address = bitcoind.client.get_new_address(None, None).unwrap();
+        bitcoind
+            .client
+            .generate_to_address(101, &node_address)
+            .unwrap();
+
+        let mut test_client = TestClient { bitcoind, electrsd };
+        TestClient::wait_for_block(&mut test_client, 101);
+        test_client
    }

    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();
            trace!("wait_for_tx {}", txid);

-            self.electrum
+            self.electrsd
+                .client
                .script_get_history(monitor_script)
                .unwrap()
                .iter()
@@ -46,12 +66,13 @@ impl TestClient {
    }

    fn wait_for_block(&mut self, min_height: usize) {
-        self.electrum.block_headers_subscribe().unwrap();
+        self.electrsd.client.block_headers_subscribe().unwrap();

        loop {
            let header = exponential_backoff_poll(|| {
-                self.electrum.ping().unwrap();
-                self.electrum.block_headers_pop().unwrap()
+                self.electrsd.trigger().unwrap();
+                self.electrsd.client.ping().unwrap();
+                self.electrsd.client.block_headers_pop().unwrap()
            });
            if header.height >= min_height {
                break;
@@ -96,10 +117,13 @@ impl TestClient {
            .unwrap();

        // broadcast through electrum so that it caches the tx immediately
+
        let txid = self
-            .electrum
+            .electrsd
+            .client
            .transaction_broadcast(&deserialize(&tx.hex).unwrap())
            .unwrap();
+        debug!("broadcasted to electrum {}", txid);

        if let Some(num) = meta_tx.min_confirmations {
            self.generate(num, None);
@@ -209,7 +233,7 @@ impl TestClient {
        let block_hex: String = serialize(&block).to_hex();
        debug!("generated block hex: {}", block_hex);

-        self.electrum.block_headers_subscribe().unwrap();
+        self.electrsd.client.block_headers_subscribe().unwrap();

        let submit_result: serde_json::Value =
            self.call("submitblock", &[block_hex.into()]).unwrap();
@@ -237,7 +261,7 @@ impl TestClient {
    }

    pub fn invalidate(&mut self, num_blocks: u64) {
-        self.electrum.block_headers_subscribe().unwrap();
+        self.electrsd.client.block_headers_subscribe().unwrap();

        let best_hash = self.get_best_block_hash().unwrap();
        let initial_height = self.get_block_info(&best_hash).unwrap().height;
@@ -288,16 +312,25 @@ impl Deref for TestClient {
    type Target = RpcClient;

    fn deref(&self) -> &Self::Target {
-        &self.client
+        &self.bitcoind.client
    }
 }

 impl Default for TestClient {
    fn default() -> Self {
-        let rpc_host_and_port =
-            env::var("BDK_RPC_URL").unwrap_or_else(|_| "127.0.0.1:18443".to_string());
-        let wallet = env::var("BDK_RPC_WALLET").unwrap_or_else(|_| "bdk-test".to_string());
-        Self::new(rpc_host_and_port, wallet)
+        let bitcoind_exe = env::var("BITCOIND_EXE")
+            .ok()
+            .or(bitcoind::downloaded_exe_path())
+            .expect(
+                "you should provide env var BITCOIND_EXE or specifiy a bitcoind version feature",
+            );
+        let electrs_exe = env::var("ELECTRS_EXE")
+            .ok()
+            .or(electrsd::downloaded_exe_path())
+            .expect(
+                "you should provide env var ELECTRS_EXE or specifiy a electrsd version feature",
+            );
+        Self::new(bitcoind_exe, electrs_exe)
    }
 }

@@ -317,27 +350,13 @@ where
    }
 }

-// TODO: we currently only support env vars, we could also parse a toml file
-fn get_auth() -> Auth {
-    match env::var("BDK_RPC_AUTH").as_ref().map(String::as_ref) {
-        Ok("USER_PASS") => Auth::UserPass(
-            env::var("BDK_RPC_USER").unwrap(),
-            env::var("BDK_RPC_PASS").unwrap(),
-        ),
-        _ => Auth::CookieFile(PathBuf::from(
-            env::var("BDK_RPC_COOKIEFILE")
-                .unwrap_or_else(|_| "/home/user/.bitcoin/regtest/.cookie".to_string()),
-        )),
-    }
-}
-
 /// This macro runs blockchain tests against a `Blockchain` implementation. It requires access to a
 /// Bitcoin core wallet via RPC. At the moment you have to dig into the code yourself and look at
 /// the setup required to run the tests yourself.
 #[macro_export]
 macro_rules! bdk_blockchain_tests {
    (
-     fn test_instance() -> $blockchain:ty $block:block) => {
+     fn $_fn_name:ident ( $( $test_client:ident : &TestClient )? $(,)? ) -> $blockchain:ty $block:block) => {
        #[cfg(test)]
        mod bdk_blockchain_tests {
            use $crate::bitcoin::Network;
@@ -347,16 +366,17 @@ macro_rules! bdk_blockchain_tests {
            use $crate::types::KeychainKind;
            use $crate::{Wallet, FeeRate};
            use $crate::testutils;
-            use $crate::serial_test::serial;

            use super::*;

-            fn get_blockchain() -> $blockchain {
+            #[allow(unused_variables)]
+            fn get_blockchain(test_client: &TestClient) -> $blockchain {
+                $( let $test_client = test_client; )?
                $block
            }

-            fn get_wallet_from_descriptors(descriptors: &(String, Option<String>)) -> Wallet<$blockchain, MemoryDatabase> {
-                Wallet::new(&descriptors.0.to_string(), descriptors.1.as_ref(), Network::Regtest, MemoryDatabase::new(), get_blockchain()).unwrap()
+            fn get_wallet_from_descriptors(descriptors: &(String, Option<String>), test_client: &TestClient) -> Wallet<$blockchain, MemoryDatabase> {
+                Wallet::new(&descriptors.0.to_string(), descriptors.1.as_ref(), Network::Regtest, MemoryDatabase::new(), get_blockchain(test_client)).unwrap()
            }

            fn init_single_sig() -> (Wallet<$blockchain, MemoryDatabase>, (String, Option<String>), TestClient) {
@@ -367,7 +387,7 @@ macro_rules! bdk_blockchain_tests {
                };

                let test_client = TestClient::default();
-                let wallet = get_wallet_from_descriptors(&descriptors);
+                let wallet = get_wallet_from_descriptors(&descriptors, &test_client);

                // rpc need to call import_multi before receiving any tx, otherwise will not see tx in the mempool
                #[cfg(feature = "test-rpc")]
@@ -377,7 +397,6 @@ macro_rules! bdk_blockchain_tests {
            }

            #[test]
-            #[serial]
            fn test_sync_simple() {
                let (wallet, descriptors, mut test_client) = init_single_sig();

@@ -400,7 +419,6 @@ macro_rules! bdk_blockchain_tests {
            }

            #[test]
-            #[serial]
            fn test_sync_stop_gap_20() {
                let (wallet, descriptors, mut test_client) = init_single_sig();

@@ -418,7 +436,6 @@ macro_rules! bdk_blockchain_tests {
            }

            #[test]
-            #[serial]
            fn test_sync_before_and_after_receive() {
                let (wallet, descriptors, mut test_client) = init_single_sig();

@@ -436,7 +453,6 @@ macro_rules! bdk_blockchain_tests {
            }

            #[test]
-            #[serial]
            fn test_sync_multiple_outputs_same_tx() {
                let (wallet, descriptors, mut test_client) = init_single_sig();

@@ -458,7 +474,6 @@ macro_rules! bdk_blockchain_tests {
            }

            #[test]
-            #[serial]
            fn test_sync_receive_multi() {
                let (wallet, descriptors, mut test_client) = init_single_sig();

@@ -477,7 +492,6 @@ macro_rules! bdk_blockchain_tests {
            }

            #[test]
-            #[serial]
            fn test_sync_address_reuse() {
                let (wallet, descriptors, mut test_client) = init_single_sig();

@@ -497,7 +511,6 @@ macro_rules! bdk_blockchain_tests {
            }

            #[test]
-            #[serial]
            fn test_sync_receive_rbf_replaced() {
                let (wallet, descriptors, mut test_client) = init_single_sig();

@@ -536,7 +549,6 @@ macro_rules! bdk_blockchain_tests {
            // doesn't work for some reason.
            #[cfg(not(feature = "esplora"))]
            #[test]
-            #[serial]
            fn test_sync_reorg_block() {
                let (wallet, descriptors, mut test_client) = init_single_sig();

@@ -567,7 +579,6 @@ macro_rules! bdk_blockchain_tests {
            }

            #[test]
-            #[serial]
            fn test_sync_after_send() {
                let (wallet, descriptors, mut test_client) = init_single_sig();
                println!("{}", descriptors.0);
@@ -588,7 +599,6 @@ macro_rules! bdk_blockchain_tests {
                let tx = psbt.extract_tx();
                println!("{}", bitcoin::consensus::encode::serialize_hex(&tx));
                wallet.broadcast(tx).unwrap();
-
                wallet.sync(noop_progress(), None).unwrap();
                assert_eq!(wallet.get_balance().unwrap(), details.received, "incorrect balance after send");

@@ -597,7 +607,6 @@ macro_rules! bdk_blockchain_tests {
            }

            #[test]
-            #[serial]
            fn test_update_confirmation_time_after_generate() {
                let (wallet, descriptors, mut test_client) = init_single_sig();
                println!("{}", descriptors.0);
@@ -623,9 +632,7 @@ macro_rules! bdk_blockchain_tests {

            }

-
            #[test]
-            #[serial]
            fn test_sync_outgoing_from_scratch() {
                let (wallet, descriptors, mut test_client) = init_single_sig();
                let node_addr = test_client.get_node_address(None);
@@ -648,7 +655,7 @@ macro_rules! bdk_blockchain_tests {
                assert_eq!(wallet.get_balance().unwrap(), details.received, "incorrect balance after receive");

                // empty wallet
-                let wallet = get_wallet_from_descriptors(&descriptors);
+                let wallet = get_wallet_from_descriptors(&descriptors, &test_client);

                #[cfg(feature = "rpc")]  // rpc cannot see mempool tx before importmulti
                test_client.generate(1, Some(node_addr));
@@ -667,7 +674,6 @@ macro_rules! bdk_blockchain_tests {
            }

            #[test]
-            #[serial]
            fn test_sync_long_change_chain() {
                let (wallet, descriptors, mut test_client) = init_single_sig();
                let node_addr = test_client.get_node_address(None);
@@ -698,7 +704,7 @@ macro_rules! bdk_blockchain_tests {

                // empty wallet

-                let wallet = get_wallet_from_descriptors(&descriptors);
+                let wallet = get_wallet_from_descriptors(&descriptors, &test_client);

                #[cfg(feature = "rpc")]  // rpc cannot see mempool tx before importmulti
                test_client.generate(1, Some(node_addr));
@@ -709,7 +715,6 @@ macro_rules! bdk_blockchain_tests {
            }

            #[test]
-            #[serial]
            fn test_sync_bump_fee_basic() {
                let (wallet, descriptors, mut test_client) = init_single_sig();
                let node_addr = test_client.get_node_address(None);
@@ -745,7 +750,6 @@ macro_rules! bdk_blockchain_tests {
            }

            #[test]
-            #[serial]
            fn test_sync_bump_fee_remove_change() {
                let (wallet, descriptors, mut test_client) = init_single_sig();
                let node_addr = test_client.get_node_address(None);
@@ -781,7 +785,6 @@ macro_rules! bdk_blockchain_tests {
            }

            #[test]
-            #[serial]
            fn test_sync_bump_fee_add_input_simple() {
                let (wallet, descriptors, mut test_client) = init_single_sig();
                let node_addr = test_client.get_node_address(None);
@@ -815,7 +818,6 @@ macro_rules! bdk_blockchain_tests {
            }

            #[test]
-            #[serial]
            fn test_sync_bump_fee_add_input_no_change() {
                let (wallet, descriptors, mut test_client) = init_single_sig();
                let node_addr = test_client.get_node_address(None);
@@ -852,7 +854,6 @@ macro_rules! bdk_blockchain_tests {
            }

            #[test]
-            #[serial]
            fn test_sync_receive_coinbase() {
                let (wallet, _, mut test_client) = init_single_sig();

@@ -875,5 +876,10 @@ macro_rules! bdk_blockchain_tests {
                assert!(wallet.get_balance().unwrap() > 0, "incorrect balance after receiving coinbase");
            }
        }
-    }
+    };
+
+    ( fn $fn_name:ident ($( $tt:tt )+) -> $blockchain:ty $block:block) => {
+        compile_error!(concat!("Invalid arguments `", stringify!($($tt)*), "` in the blockchain tests fn."));
+        compile_error!("Only the exact `&TestClient` type is supported, **without** any leading path items.");
+    };
 }
--- a/src/testutils/mod.rs
+++ b/src/testutils/mod.rs
@@ -10,6 +10,7 @@
 // licenses.
 #![allow(missing_docs)]

+#[cfg(test)]
 #[cfg(feature = "test-blockchains")]
 pub mod blockchain_tests;

--- a/src/types.rs
+++ b/src/types.rs
@@ -10,6 +10,7 @@
 // licenses.

 use std::convert::AsRef;
+use std::ops::Sub;

 use bitcoin::blockdata::transaction::{OutPoint, Transaction, TxOut};
 use bitcoin::{hash_types::Txid, util::psbt};
@@ -65,10 +66,31 @@ impl FeeRate {
        FeeRate(1.0)
    }

+    /// Calculate fee rate from `fee` and weight units (`wu`).
+    pub fn from_wu(fee: u64, wu: usize) -> FeeRate {
+        Self::from_vb(fee, wu.vbytes())
+    }
+
+    /// Calculate fee rate from `fee` and `vbytes`.
+    pub fn from_vb(fee: u64, vbytes: usize) -> FeeRate {
+        let rate = fee as f32 / vbytes as f32;
+        Self::from_sat_per_vb(rate)
+    }
+
    /// Return the value as satoshi/vbyte
    pub fn as_sat_vb(&self) -> f32 {
        self.0
    }
+
+    /// Calculate absolute fee in Satoshis using size in weight units.
+    pub fn fee_wu(&self, wu: usize) -> u64 {
+        self.fee_vb(wu.vbytes())
+    }
+
+    /// Calculate absolute fee in Satoshis using size in virtual bytes.
+    pub fn fee_vb(&self, vbytes: usize) -> u64 {
+        (self.as_sat_vb() * vbytes as f32).ceil() as u64
+    }
 }

 impl std::default::Default for FeeRate {
@@ -77,6 +99,27 @@ impl std::default::Default for FeeRate {
    }
 }

+impl Sub for FeeRate {
+    type Output = Self;
+
+    fn sub(self, other: FeeRate) -> Self::Output {
+        FeeRate(self.0 - other.0)
+    }
+}
+
+/// Trait implemented by types that can be used to measure weight units.
+pub trait Vbytes {
+    /// Convert weight units to virtual bytes.
+    fn vbytes(self) -> usize;
+}
+
+impl Vbytes for usize {
+    fn vbytes(self) -> usize {
+        // ref: https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki#transaction-size-calculations
+        (self as f32 / 4.0).ceil() as usize
+    }
+}
+
 /// An unspent output owned by a [`Wallet`].
 ///
 /// [`Wallet`]: crate::Wallet
@@ -160,7 +203,10 @@ pub struct TransactionDetails {
    pub received: u64,
    /// Sent value (sats)
    pub sent: u64,
-    /// Fee value (sats) if available
+    /// Fee value (sats) if available.
+    /// The availability of the fee depends on the backend. It's never `None` with an Electrum
+    /// Server backend, but it could be `None` with a Bitcoin RPC node without txindex that receive
+    /// funds while offline.
    pub fee: Option<u64>,
    /// If the transaction is confirmed, contains height and timestamp of the block containing the
    /// transaction, unconfirmed transaction contains `None`.
--- a/src/wallet/address_validator.rs
+++ b/src/wallet/address_validator.rs
@@ -115,8 +115,8 @@ mod test {
    use std::sync::Arc;

    use super::*;
-    use crate::wallet::test::{get_funded_wallet, get_test_wpkh};
    use crate::wallet::AddressIndex::New;
+    use crate::wallet::{get_funded_wallet, test::get_test_wpkh};

    #[derive(Debug)]
    struct TestValidator;
--- a/src/wallet/coin_selection.rs
+++ b/src/wallet/coin_selection.rs
@@ -26,7 +26,7 @@
 //! ```
 //! # use std::str::FromStr;
 //! # use bitcoin::*;
-//! # use bdk::wallet::coin_selection::*;
+//! # use bdk::wallet::{self, coin_selection::*};
 //! # use bdk::database::Database;
 //! # use bdk::*;
 //! # const TXIN_BASE_WEIGHT: usize = (32 + 4 + 4 + 1) * 4;
@@ -41,7 +41,7 @@
 //!         optional_utxos: Vec<WeightedUtxo>,
 //!         fee_rate: FeeRate,
 //!         amount_needed: u64,
-//!         fee_amount: f32,
+//!         fee_amount: u64,
 //!     ) -> Result<CoinSelectionResult, bdk::Error> {
 //!         let mut selected_amount = 0;
 //!         let mut additional_weight = 0;
@@ -57,9 +57,8 @@
 //!                 },
 //!             )
 //!             .collect::<Vec<_>>();
-//!         let additional_fees = additional_weight as f32 * fee_rate.as_sat_vb() / 4.0;
-//!         let amount_needed_with_fees =
-//!             (fee_amount + additional_fees).ceil() as u64 + amount_needed;
+//!         let additional_fees = fee_rate.fee_wu(additional_weight);
+//!         let amount_needed_with_fees = (fee_amount + additional_fees) + amount_needed;
 //!         if amount_needed_with_fees > selected_amount {
 //!             return Err(bdk::Error::InsufficientFunds {
 //!                 needed: amount_needed_with_fees,
@@ -117,7 +116,7 @@ pub struct CoinSelectionResult {
    /// List of outputs selected for use as inputs
    pub selected: Vec<Utxo>,
    /// Total fee amount in satoshi
-    pub fee_amount: f32,
+    pub fee_amount: u64,
 }

 impl CoinSelectionResult {
@@ -164,7 +163,7 @@ pub trait CoinSelectionAlgorithm<D: Database>: std::fmt::Debug {
        optional_utxos: Vec<WeightedUtxo>,
        fee_rate: FeeRate,
        amount_needed: u64,
-        fee_amount: f32,
+        fee_amount: u64,
    ) -> Result<CoinSelectionResult, Error>;
 }

@@ -183,10 +182,8 @@ impl<D: Database> CoinSelectionAlgorithm<D> for LargestFirstCoinSelection {
        mut optional_utxos: Vec<WeightedUtxo>,
        fee_rate: FeeRate,
        amount_needed: u64,
-        mut fee_amount: f32,
+        mut fee_amount: u64,
    ) -> Result<CoinSelectionResult, Error> {
-        let calc_fee_bytes = |wu| (wu as f32) * fee_rate.as_sat_vb() / 4.0;
-
        log::debug!(
            "amount_needed = `{}`, fee_amount = `{}`, fee_rate = `{:?}`",
            amount_needed,
@@ -211,9 +208,9 @@ impl<D: Database> CoinSelectionAlgorithm<D> for LargestFirstCoinSelection {
            .scan(
                (&mut selected_amount, &mut fee_amount),
                |(selected_amount, fee_amount), (must_use, weighted_utxo)| {
-                    if must_use || **selected_amount < amount_needed + (fee_amount.ceil() as u64) {
+                    if must_use || **selected_amount < amount_needed + **fee_amount {
                        **fee_amount +=
-                            calc_fee_bytes(TXIN_BASE_WEIGHT + weighted_utxo.satisfaction_weight);
+                            fee_rate.fee_wu(TXIN_BASE_WEIGHT + weighted_utxo.satisfaction_weight);
                        **selected_amount += weighted_utxo.utxo.txout().value;

                        log::debug!(
@@ -230,7 +227,7 @@ impl<D: Database> CoinSelectionAlgorithm<D> for LargestFirstCoinSelection {
            )
            .collect::<Vec<_>>();

-        let amount_needed_with_fees = amount_needed + (fee_amount.ceil() as u64);
+        let amount_needed_with_fees = amount_needed + fee_amount;
        if selected_amount < amount_needed_with_fees {
            return Err(Error::InsufficientFunds {
                needed: amount_needed_with_fees,
@@ -250,16 +247,15 @@ impl<D: Database> CoinSelectionAlgorithm<D> for LargestFirstCoinSelection {
 struct OutputGroup {
    weighted_utxo: WeightedUtxo,
    // Amount of fees for spending a certain utxo, calculated using a certain FeeRate
-    fee: f32,
+    fee: u64,
    // The effective value of the UTXO, i.e., the utxo value minus the fee for spending it
    effective_value: i64,
 }

 impl OutputGroup {
    fn new(weighted_utxo: WeightedUtxo, fee_rate: FeeRate) -> Self {
-        let fee = (TXIN_BASE_WEIGHT + weighted_utxo.satisfaction_weight) as f32 / 4.0
-            * fee_rate.as_sat_vb();
-        let effective_value = weighted_utxo.utxo.txout().value as i64 - fee.ceil() as i64;
+        let fee = fee_rate.fee_wu(TXIN_BASE_WEIGHT + weighted_utxo.satisfaction_weight);
+        let effective_value = weighted_utxo.utxo.txout().value as i64 - fee as i64;
        OutputGroup {
            weighted_utxo,
            fee,
@@ -302,7 +298,7 @@ impl<D: Database> CoinSelectionAlgorithm<D> for BranchAndBoundCoinSelection {
        optional_utxos: Vec<WeightedUtxo>,
        fee_rate: FeeRate,
        amount_needed: u64,
-        fee_amount: f32,
+        fee_amount: u64,
    ) -> Result<CoinSelectionResult, Error> {
        // Mapping every (UTXO, usize) to an output group
        let required_utxos: Vec<OutputGroup> = required_utxos
@@ -324,7 +320,7 @@ impl<D: Database> CoinSelectionAlgorithm<D> for BranchAndBoundCoinSelection {
            .iter()
            .fold(0, |acc, x| acc + x.effective_value);

-        let actual_target = fee_amount.ceil() as u64 + amount_needed;
+        let actual_target = fee_amount + amount_needed;
        let cost_of_change = self.size_of_change as f32 * fee_rate.as_sat_vb();

        let expected = (curr_available_value + curr_value)
@@ -344,6 +340,14 @@ impl<D: Database> CoinSelectionAlgorithm<D> for BranchAndBoundCoinSelection {
            .try_into()
            .expect("Bitcoin amount to fit into i64");

+        if curr_value > actual_target {
+            return Ok(BranchAndBoundCoinSelection::calculate_cs_result(
+                vec![],
+                required_utxos,
+                fee_amount,
+            ));
+        }
+
        Ok(self
            .bnb(
                required_utxos.clone(),
@@ -377,7 +381,7 @@ impl BranchAndBoundCoinSelection {
        mut curr_value: i64,
        mut curr_available_value: i64,
        actual_target: i64,
-        fee_amount: f32,
+        fee_amount: u64,
        cost_of_change: f32,
    ) -> Result<CoinSelectionResult, Error> {
        // current_selection[i] will contain true if we are using optional_utxos[i],
@@ -485,7 +489,7 @@ impl BranchAndBoundCoinSelection {
        mut optional_utxos: Vec<OutputGroup>,
        curr_value: i64,
        actual_target: i64,
-        fee_amount: f32,
+        fee_amount: u64,
    ) -> CoinSelectionResult {
        #[cfg(not(test))]
        optional_utxos.shuffle(&mut thread_rng());
@@ -514,10 +518,10 @@ impl BranchAndBoundCoinSelection {
    fn calculate_cs_result(
        mut selected_utxos: Vec<OutputGroup>,
        mut required_utxos: Vec<OutputGroup>,
-        mut fee_amount: f32,
+        mut fee_amount: u64,
    ) -> CoinSelectionResult {
        selected_utxos.append(&mut required_utxos);
-        fee_amount += selected_utxos.iter().map(|u| u.fee).sum::<f32>();
+        fee_amount += selected_utxos.iter().map(|u| u.fee).sum::<u64>();
        let selected = selected_utxos
            .into_iter()
            .map(|u| u.weighted_utxo.utxo)
@@ -539,6 +543,7 @@ mod test {
    use super::*;
    use crate::database::MemoryDatabase;
    use crate::types::*;
+    use crate::wallet::Vbytes;

    use rand::rngs::StdRng;
    use rand::seq::SliceRandom;
@@ -546,52 +551,33 @@ mod test {

    const P2WPKH_WITNESS_SIZE: usize = 73 + 33 + 2;

-    const FEE_AMOUNT: f32 = 50.0;
+    const FEE_AMOUNT: u64 = 50;
+
+    fn utxo(value: u64, index: u32) -> WeightedUtxo {
+        assert!(index < 10);
+        let outpoint = OutPoint::from_str(&format!(
+            "000000000000000000000000000000000000000000000000000000000000000{}:0",
+            index
+        ))
+        .unwrap();
+        WeightedUtxo {
+            satisfaction_weight: P2WPKH_WITNESS_SIZE,
+            utxo: Utxo::Local(LocalUtxo {
+                outpoint,
+                txout: TxOut {
+                    value,
+                    script_pubkey: Script::new(),
+                },
+                keychain: KeychainKind::External,
+            }),
+        }
+    }

    fn get_test_utxos() -> Vec<WeightedUtxo> {
        vec![
-            WeightedUtxo {
-                satisfaction_weight: P2WPKH_WITNESS_SIZE,
-                utxo: Utxo::Local(LocalUtxo {
-                    outpoint: OutPoint::from_str(
-                        "0000000000000000000000000000000000000000000000000000000000000000:0",
-                    )
-                    .unwrap(),
-                    txout: TxOut {
-                        value: 100_000,
-                        script_pubkey: Script::new(),
-                    },
-                    keychain: KeychainKind::External,
-                }),
-            },
-            WeightedUtxo {
-                satisfaction_weight: P2WPKH_WITNESS_SIZE,
-                utxo: Utxo::Local(LocalUtxo {
-                    outpoint: OutPoint::from_str(
-                        "0000000000000000000000000000000000000000000000000000000000000001:0",
-                    )
-                    .unwrap(),
-                    txout: TxOut {
-                        value: FEE_AMOUNT as u64 - 40,
-                        script_pubkey: Script::new(),
-                    },
-                    keychain: KeychainKind::External,
-                }),
-            },
-            WeightedUtxo {
-                satisfaction_weight: P2WPKH_WITNESS_SIZE,
-                utxo: Utxo::Local(LocalUtxo {
-                    outpoint: OutPoint::from_str(
-                        "0000000000000000000000000000000000000000000000000000000000000002:0",
-                    )
-                    .unwrap(),
-                    txout: TxOut {
-                        value: 200_000,
-                        script_pubkey: Script::new(),
-                    },
-                    keychain: KeychainKind::Internal,
-                }),
-            },
+            utxo(100_000, 0),
+            utxo(FEE_AMOUNT as u64 - 40, 1),
+            utxo(200_000, 2),
        ]
    }

@@ -655,13 +641,13 @@ mod test {
                vec![],
                FeeRate::from_sat_per_vb(1.0),
                250_000,
-                50.0,
+                FEE_AMOUNT,
            )
            .unwrap();

        assert_eq!(result.selected.len(), 3);
        assert_eq!(result.selected_amount(), 300_010);
-        assert!((result.fee_amount - 254.0).abs() < f32::EPSILON);
+        assert_eq!(result.fee_amount, 254)
    }

    #[test]
@@ -676,13 +662,13 @@ mod test {
                vec![],
                FeeRate::from_sat_per_vb(1.0),
                20_000,
-                50.0,
+                FEE_AMOUNT,
            )
            .unwrap();

        assert_eq!(result.selected.len(), 3);
        assert_eq!(result.selected_amount(), 300_010);
-        assert!((result.fee_amount - 254.0).abs() < f32::EPSILON);
+        assert_eq!(result.fee_amount, 254);
    }

    #[test]
@@ -697,13 +683,13 @@ mod test {
                utxos,
                FeeRate::from_sat_per_vb(1.0),
                20_000,
-                50.0,
+                FEE_AMOUNT,
            )
            .unwrap();

        assert_eq!(result.selected.len(), 1);
        assert_eq!(result.selected_amount(), 200_000);
-        assert!((result.fee_amount - 118.0).abs() < f32::EPSILON);
+        assert_eq!(result.fee_amount, 118);
    }

    #[test]
@@ -719,7 +705,7 @@ mod test {
                utxos,
                FeeRate::from_sat_per_vb(1.0),
                500_000,
-                50.0,
+                FEE_AMOUNT,
            )
            .unwrap();
    }
@@ -737,7 +723,7 @@ mod test {
                utxos,
                FeeRate::from_sat_per_vb(1000.0),
                250_000,
-                50.0,
+                FEE_AMOUNT,
            )
            .unwrap();
    }
@@ -757,13 +743,13 @@ mod test {
                utxos,
                FeeRate::from_sat_per_vb(1.0),
                250_000,
-                50.0,
+                FEE_AMOUNT,
            )
            .unwrap();

        assert_eq!(result.selected.len(), 3);
        assert_eq!(result.selected_amount(), 300_000);
-        assert!((result.fee_amount - 254.0).abs() < f32::EPSILON);
+        assert_eq!(result.fee_amount, 254);
    }

    #[test]
@@ -784,7 +770,7 @@ mod test {

        assert_eq!(result.selected.len(), 3);
        assert_eq!(result.selected_amount(), 300_010);
-        assert!((result.fee_amount - 254.0).abs() < f32::EPSILON);
+        assert_eq!(result.fee_amount, 254);
    }

    #[test]
@@ -805,7 +791,38 @@ mod test {

        assert_eq!(result.selected.len(), 3);
        assert_eq!(result.selected_amount(), 300010);
-        assert!((result.fee_amount - 254.0).abs() < f32::EPSILON);
+        assert_eq!(result.fee_amount, 254);
+    }
+
+    #[test]
+    fn test_bnb_coin_selection_required_not_enough() {
+        let utxos = get_test_utxos();
+        let database = MemoryDatabase::default();
+
+        let required = vec![utxos[0].clone()];
+        let mut optional = utxos[1..].to_vec();
+        optional.push(utxo(500_000, 3));
+
+        // Defensive assertions, for sanity and in case someone changes the test utxos vector.
+        let amount: u64 = required.iter().map(|u| u.utxo.txout().value).sum();
+        assert_eq!(amount, 100_000);
+        let amount: u64 = optional.iter().map(|u| u.utxo.txout().value).sum();
+        assert!(amount > 150_000);
+
+        let result = BranchAndBoundCoinSelection::default()
+            .coin_select(
+                &database,
+                required,
+                optional,
+                FeeRate::from_sat_per_vb(1.0),
+                150_000,
+                FEE_AMOUNT,
+            )
+            .unwrap();
+
+        assert_eq!(result.selected.len(), 3);
+        assert_eq!(result.selected_amount(), 300_010);
+        assert!((result.fee_amount as f32 - 254.0).abs() < f32::EPSILON);
    }

    #[test]
@@ -821,7 +838,7 @@ mod test {
                utxos,
                FeeRate::from_sat_per_vb(1.0),
                500_000,
-                50.0,
+                FEE_AMOUNT,
            )
            .unwrap();
    }
@@ -839,7 +856,7 @@ mod test {
                utxos,
                FeeRate::from_sat_per_vb(1000.0),
                250_000,
-                50.0,
+                FEE_AMOUNT,
            )
            .unwrap();
    }
@@ -856,15 +873,15 @@ mod test {
                utxos,
                FeeRate::from_sat_per_vb(1.0),
                99932, // first utxo's effective value
-                0.0,
+                0,
            )
            .unwrap();

        assert_eq!(result.selected.len(), 1);
        assert_eq!(result.selected_amount(), 100_000);
-        let input_size = (TXIN_BASE_WEIGHT as f32) / 4.0 + P2WPKH_WITNESS_SIZE as f32 / 4.0;
+        let input_size = (TXIN_BASE_WEIGHT + P2WPKH_WITNESS_SIZE).vbytes();
        let epsilon = 0.5;
-        assert!((1.0 - (result.fee_amount / input_size)).abs() < epsilon);
+        assert!((1.0 - (result.fee_amount as f32 / input_size as f32)).abs() < epsilon);
    }

    #[test]
@@ -883,7 +900,7 @@ mod test {
                    optional_utxos,
                    FeeRate::from_sat_per_vb(0.0),
                    target_amount,
-                    0.0,
+                    0,
                )
                .unwrap();
            assert_eq!(result.selected_amount(), target_amount);
@@ -910,7 +927,7 @@ mod test {
                0,
                curr_available_value,
                20_000,
-                50.0,
+                FEE_AMOUNT,
                cost_of_change,
            )
            .unwrap();
@@ -937,7 +954,7 @@ mod test {
                0,
                curr_available_value,
                20_000,
-                50.0,
+                FEE_AMOUNT,
                cost_of_change,
            )
            .unwrap();
@@ -949,7 +966,6 @@ mod test {
        let fee_rate = FeeRate::from_sat_per_vb(1.0);
        let size_of_change = 31;
        let cost_of_change = size_of_change as f32 * fee_rate.as_sat_vb();
-        let fee_amount = 50.0;

        let utxos: Vec<_> = generate_same_value_utxos(50_000, 10)
            .into_iter()
@@ -971,12 +987,12 @@ mod test {
                curr_value,
                curr_available_value,
                target_amount,
-                fee_amount,
+                FEE_AMOUNT,
                cost_of_change,
            )
            .unwrap();
-        assert!((result.fee_amount - 186.0).abs() < f32::EPSILON);
        assert_eq!(result.selected_amount(), 100_000);
+        assert_eq!(result.fee_amount, 186);
    }

    // TODO: bnb() function should be optimized, and this test should be done with more utxos
@@ -1008,7 +1024,7 @@ mod test {
                    curr_value,
                    curr_available_value,
                    target_amount,
-                    0.0,
+                    0,
                    0.0,
                )
                .unwrap();
@@ -1034,12 +1050,10 @@ mod test {
            utxos,
            0,
            target_amount as i64,
-            50.0,
+            FEE_AMOUNT,
        );

        assert!(result.selected_amount() > target_amount);
-        assert!(
-            (result.fee_amount - (50.0 + result.selected.len() as f32 * 68.0)).abs() < f32::EPSILON
-        );
+        assert_eq!(result.fee_amount, (50 + result.selected.len() * 68) as u64);
    }
 }
--- a/src/wallet/mod.rs
+++ b/src/wallet/mod.rs
@@ -18,6 +18,7 @@ use std::collections::HashMap;
 use std::collections::{BTreeMap, HashSet};
 use std::fmt;
 use std::ops::{Deref, DerefMut};
+use std::str::FromStr;
 use std::sync::Arc;

 use bitcoin::secp256k1::Secp256k1;
@@ -55,6 +56,7 @@ use tx_builder::{BumpFee, CreateTx, FeePolicy, TxBuilder, TxParams};
 use utils::{check_nlocktime, check_nsequence_rbf, After, Older, SecpCtx, DUST_LIMIT_SATOSHI};

 use crate::blockchain::{Blockchain, Progress};
+use crate::database::memory::MemoryDatabase;
 use crate::database::{BatchDatabase, BatchOperations, DatabaseUtils};
 use crate::descriptor::derived::AsDerived;
 use crate::descriptor::policy::BuildSatisfaction;
@@ -66,6 +68,7 @@ use crate::descriptor::{
 use crate::error::Error;
 use crate::psbt::PsbtUtils;
 use crate::signer::SignerError;
+use crate::testutils;
 use crate::types::*;

 const CACHE_ADDR_BATCH_SIZE: u32 = 100;
@@ -167,6 +170,11 @@ where
            secp,
        })
    }
+
+    /// Get the Bitcoin network the wallet is using.
+    pub fn network(&self) -> Network {
+        self.network
+    }
 }

 /// The address index selection strategy to use to derived an address from the wallet's external
@@ -543,7 +551,7 @@ where
                        });
                    }
                }
-                (FeeRate::from_sat_per_vb(0.0), *fee as f32)
+                (FeeRate::from_sat_per_vb(0.0), *fee)
            }
            FeePolicy::FeeRate(rate) => {
                if let Some(previous_fee) = params.bumping_fee {
@@ -554,7 +562,7 @@ where
                        });
                    }
                }
-                (*rate, 0.0)
+                (*rate, 0)
            }
        };

@@ -565,21 +573,6 @@ where
            output: vec![],
        };

-        let recipients = match &params.single_recipient {
-            Some(recipient) => vec![(recipient, 0)],
-            None => params.recipients.iter().map(|(r, v)| (r, *v)).collect(),
-        };
-        if params.single_recipient.is_some()
-            && !params.manually_selected_only
-            && !params.drain_wallet
-            && params.bumping_fee.is_none()
-        {
-            return Err(Error::SingleRecipientNoInputs);
-        }
-        if recipients.is_empty() {
-            return Err(Error::NoRecipients);
-        }
-
        if params.manually_selected_only && params.utxos.is_empty() {
            return Err(Error::NoUtxosSelected);
        }
@@ -588,15 +581,14 @@ where
        let mut outgoing: u64 = 0;
        let mut received: u64 = 0;

-        let calc_fee_bytes = |wu| (wu as f32) * fee_rate.as_sat_vb() / 4.0;
-        fee_amount += calc_fee_bytes(tx.get_weight());
+        fee_amount += fee_rate.fee_wu(tx.get_weight());

-        for (index, (script_pubkey, satoshi)) in recipients.into_iter().enumerate() {
-            let value = match params.single_recipient {
-                Some(_) => 0,
-                None if satoshi.is_dust() => return Err(Error::OutputBelowDustLimit(index)),
-                None => satoshi,
-            };
+        let recipients = params.recipients.iter().map(|(r, v)| (r, *v));
+
+        for (index, (script_pubkey, value)) in recipients.enumerate() {
+            if value.is_dust() {
+                return Err(Error::OutputBelowDustLimit(index));
+            }

            if self.is_mine(script_pubkey)? {
                received += value;
@@ -606,7 +598,7 @@ where
                script_pubkey: script_pubkey.clone(),
                value,
            };
-            fee_amount += calc_fee_bytes(serialize(&new_out).len() * 4);
+            fee_amount += fee_rate.fee_vb(serialize(&new_out).len());

            tx.output.push(new_out);

@@ -651,54 +643,46 @@ where
            })
            .collect();

-        // prepare the change output
-        let change_output = match params.single_recipient {
-            Some(_) => None,
-            None => {
-                let change_script = self.get_change_address()?;
-                let change_output = TxOut {
-                    script_pubkey: change_script,
-                    value: 0,
-                };
+        // prepare the drain output
+        let mut drain_output = {
+            let script_pubkey = match params.drain_to {
+                Some(ref drain_recipient) => drain_recipient.clone(),
+                None => self.get_change_address()?,
+            };

-                // take the change into account for fees
-                fee_amount += calc_fee_bytes(serialize(&change_output).len() * 4);
-                Some(change_output)
+            TxOut {
+                script_pubkey,
+                value: 0,
            }
        };
-        let mut fee_amount = fee_amount.ceil() as u64;
-        let change_val = (coin_selection.selected_amount() - outgoing).saturating_sub(fee_amount);

-        match change_output {
-            None if change_val.is_dust() => {
-                // single recipient, but the only output would be below dust limit
-                // TODO: or OutputBelowDustLimit?
-                return Err(Error::InsufficientFunds {
-                    needed: DUST_LIMIT_SATOSHI,
-                    available: change_val,
-                });
-            }
-            Some(_) if change_val.is_dust() => {
-                // skip the change output because it's dust -- just include it in the fee.
-                fee_amount += change_val;
-            }
-            Some(mut change_output) => {
-                change_output.value = change_val;
-                received += change_val;
+        fee_amount += fee_rate.fee_vb(serialize(&drain_output).len());

-                tx.output.push(change_output);
-            }
-            None => {
-                // there's only one output, send everything to it
-                tx.output[0].value = change_val;
+        let drain_val = (coin_selection.selected_amount() - outgoing).saturating_sub(fee_amount);

-                // the single recipient is our address
-                if self.is_mine(&tx.output[0].script_pubkey)? {
-                    received = change_val;
+        if tx.output.is_empty() {
+            if params.drain_to.is_some() {
+                if drain_val.is_dust() {
+                    return Err(Error::InsufficientFunds {
+                        needed: DUST_LIMIT_SATOSHI,
+                        available: drain_val,
+                    });
                }
+            } else {
+                return Err(Error::NoRecipients);
            }
        }

+        if drain_val.is_dust() {
+            fee_amount += drain_val;
+        } else {
+            drain_output.value = drain_val;
+            if self.is_mine(&drain_output.script_pubkey)? {
+                received += drain_val;
+            }
+            tx.output.push(drain_output);
+        }
+
        // sort input/outputs according to the chosen algorithm
        params.ordering.sort_tx(&mut tx);

@@ -725,10 +709,6 @@ where
    /// *repalce by fee* (RBF). If the transaction can be fee bumped then it returns a [`TxBuilder`]
    /// pre-populated with the inputs and outputs of the original transaction.
    ///
-    /// **NOTE**: if the original transaction was made with [`TxBuilder::set_single_recipient`],
-    /// the [`TxBuilder::maintain_single_recipient`] flag should be enabled to correctly reduce the
-    /// only output's value in order to increase the fees.
-    ///
    /// ## Example
    ///
    /// ```no_run
@@ -780,8 +760,10 @@ where
            return Err(Error::IrreplaceableTransaction);
        }

-        let vbytes = tx.get_weight() as f32 / 4.0;
-        let feerate = details.fee.ok_or(Error::FeeRateUnavailable)? as f32 / vbytes;
+        let feerate = FeeRate::from_wu(
+            details.fee.ok_or(Error::FeeRateUnavailable)?,
+            tx.get_weight(),
+        );

        // remove the inputs from the tx and process them
        let original_txin = tx.input.drain(..).collect::<Vec<_>>();
@@ -858,7 +840,7 @@ where
            utxos: original_utxos,
            bumping_fee: Some(tx_builder::PreviousFee {
                absolute: details.fee.ok_or(Error::FeeRateUnavailable)?,
-                rate: feerate,
+                rate: feerate.as_sat_vb(),
            }),
            ..Default::default()
        };
@@ -1526,17 +1508,13 @@ where
        // TODO: what if i generate an address first and cache some addresses?
        // TODO: we should sync if generating an address triggers a new batch to be stored
        if run_setup {
-            maybe_await!(self.client.setup(
-                None,
-                self.database.borrow_mut().deref_mut(),
-                progress_update,
-            ))?;
+            maybe_await!(self
+                .client
+                .setup(self.database.borrow_mut().deref_mut(), progress_update,))?;
        } else {
-            maybe_await!(self.client.sync(
-                None,
-                self.database.borrow_mut().deref_mut(),
-                progress_update,
-            ))?;
+            maybe_await!(self
+                .client
+                .sync(self.database.borrow_mut().deref_mut(), progress_update,))?;
        }

        #[cfg(feature = "verify")]
@@ -1564,11 +1542,6 @@ where
        &self.client
    }

-    /// Get the Bitcoin network the wallet is using.
-    pub fn network(&self) -> Network {
-        self.network
-    }
-
    /// Broadcast a transaction to the network
    #[maybe_async]
    pub fn broadcast(&self, tx: Transaction) -> Result<Txid, Error> {
@@ -1578,19 +1551,60 @@ where
    }
 }

+/// Return a fake wallet that appears to be funded for testing.
+pub fn get_funded_wallet(
+    descriptor: &str,
+) -> (
+    Wallet<(), MemoryDatabase>,
+    (String, Option<String>),
+    bitcoin::Txid,
+) {
+    let descriptors = testutils!(@descriptors (descriptor));
+    let wallet = Wallet::new_offline(
+        &descriptors.0,
+        None,
+        Network::Regtest,
+        MemoryDatabase::new(),
+    )
+    .unwrap();
+
+    let funding_address_kix = 0;
+
+    let tx_meta = testutils! {
+            @tx ( (@external descriptors, funding_address_kix) => 50_000 ) (@confirmations 1)
+    };
+
+    wallet
+        .database
+        .borrow_mut()
+        .set_script_pubkey(
+            &bitcoin::Address::from_str(&tx_meta.output.get(0).unwrap().to_address)
+                .unwrap()
+                .script_pubkey(),
+            KeychainKind::External,
+            funding_address_kix,
+        )
+        .unwrap();
+    wallet
+        .database
+        .borrow_mut()
+        .set_last_index(KeychainKind::External, funding_address_kix)
+        .unwrap();
+
+    let txid = crate::populate_test_db!(wallet.database.borrow_mut(), tx_meta, Some(100));
+
+    (wallet, descriptors, txid)
+}
+
 #[cfg(test)]
 pub(crate) mod test {
-    use std::str::FromStr;
-
    use bitcoin::{util::psbt, Network};

-    use crate::database::memory::MemoryDatabase;
    use crate::database::Database;
    use crate::types::KeychainKind;

    use super::*;
    use crate::signer::{SignOptions, SignerError};
-    use crate::testutils;
    use crate::wallet::AddressIndex::{LastUnused, New, Peek, Reset};

    #[test]
@@ -1702,50 +1716,6 @@ pub(crate) mod test {
        "wsh(and_v(v:pk(cVpPVruEDdmutPzisEsYvtST1usBR3ntr8pXSyt6D2YYqXRyPcFW),after(100000)))"
    }

-    pub(crate) fn get_funded_wallet(
-        descriptor: &str,
-    ) -> (
-        Wallet<(), MemoryDatabase>,
-        (String, Option<String>),
-        bitcoin::Txid,
-    ) {
-        let descriptors = testutils!(@descriptors (descriptor));
-        let wallet = Wallet::new_offline(
-            &descriptors.0,
-            None,
-            Network::Regtest,
-            MemoryDatabase::new(),
-        )
-        .unwrap();
-
-        let funding_address_kix = 0;
-
-        let tx_meta = testutils! {
-                @tx ( (@external descriptors, funding_address_kix) => 50_000 ) (@confirmations 1)
-        };
-
-        wallet
-            .database
-            .borrow_mut()
-            .set_script_pubkey(
-                &bitcoin::Address::from_str(&tx_meta.output.get(0).unwrap().to_address)
-                    .unwrap()
-                    .script_pubkey(),
-                KeychainKind::External,
-                funding_address_kix,
-            )
-            .unwrap();
-        wallet
-            .database
-            .borrow_mut()
-            .set_last_index(KeychainKind::External, funding_address_kix)
-            .unwrap();
-
-        let txid = crate::populate_test_db!(wallet.database.borrow_mut(), tx_meta, Some(100));
-
-        (wallet, descriptors, txid)
-    }
-
    macro_rules! assert_fee_rate {
        ($tx:expr, $fees:expr, $fee_rate:expr $( ,@dust_change $( $dust_change:expr )* )* $( ,@add_signature $( $add_signature:expr )* )* ) => ({
            let mut tx = $tx.clone();
@@ -1764,13 +1734,13 @@ pub(crate) mod test {
                dust_change = true;
            )*

-            let tx_fee_rate = $fees as f32 / (tx.get_weight() as f32 / 4.0);
-            let fee_rate = $fee_rate.as_sat_vb();
+            let tx_fee_rate = FeeRate::from_wu($fees, tx.get_weight());
+            let fee_rate = $fee_rate;

            if !dust_change {
-                assert!((tx_fee_rate - fee_rate).abs() < 0.5, "Expected fee rate of {}, the tx has {}", fee_rate, tx_fee_rate);
+                assert!((tx_fee_rate - fee_rate).as_sat_vb().abs() < 0.5, "Expected fee rate of {:?}, the tx has {:?}", fee_rate, tx_fee_rate);
            } else {
-                assert!(tx_fee_rate >= fee_rate, "Expected fee rate of at least {}, the tx has {}", fee_rate, tx_fee_rate);
+                assert!(tx_fee_rate >= fee_rate, "Expected fee rate of at least {:?}, the tx has {:?}", fee_rate, tx_fee_rate);
            }
        });
    }
@@ -1996,13 +1966,11 @@ pub(crate) mod test {
    }

    #[test]
-    fn test_create_tx_single_recipient_drain_wallet() {
+    fn test_create_tx_drain_wallet_and_drain_to() {
        let (wallet, _, _) = get_funded_wallet(get_test_wpkh());
        let addr = wallet.get_address(New).unwrap();
        let mut builder = wallet.build_tx();
-        builder
-            .set_single_recipient(addr.script_pubkey())
-            .drain_wallet();
+        builder.drain_to(addr.script_pubkey()).drain_wallet();
        let (psbt, details) = builder.finish().unwrap();

        assert_eq!(psbt.global.unsigned_tx.output.len(), 1);
@@ -2012,6 +1980,33 @@ pub(crate) mod test {
        );
    }

+    #[test]
+    fn test_create_tx_drain_wallet_and_drain_to_and_with_recipient() {
+        let (wallet, _, _) = get_funded_wallet(get_test_wpkh());
+        let addr = Address::from_str("2N4eQYCbKUHCCTUjBJeHcJp9ok6J2GZsTDt").unwrap();
+        let drain_addr = wallet.get_address(New).unwrap();
+        let mut builder = wallet.build_tx();
+        builder
+            .add_recipient(addr.script_pubkey(), 20_000)
+            .drain_to(drain_addr.script_pubkey())
+            .drain_wallet();
+        let (psbt, details) = builder.finish().unwrap();
+        dbg!(&psbt);
+        let outputs = psbt.global.unsigned_tx.output;
+
+        assert_eq!(outputs.len(), 2);
+        let main_output = outputs
+            .iter()
+            .find(|x| x.script_pubkey == addr.script_pubkey())
+            .unwrap();
+        let drain_output = outputs
+            .iter()
+            .find(|x| x.script_pubkey == drain_addr.script_pubkey())
+            .unwrap();
+        assert_eq!(main_output.value, 20_000,);
+        assert_eq!(drain_output.value, 30_000 - details.fee.unwrap_or(0));
+    }
+
    #[test]
    fn test_create_tx_default_fee_rate() {
        let (wallet, _, _) = get_funded_wallet(get_test_wpkh());
@@ -2042,7 +2037,7 @@ pub(crate) mod test {
        let addr = wallet.get_address(New).unwrap();
        let mut builder = wallet.build_tx();
        builder
-            .set_single_recipient(addr.script_pubkey())
+            .drain_to(addr.script_pubkey())
            .drain_wallet()
            .fee_absolute(100);
        let (psbt, details) = builder.finish().unwrap();
@@ -2061,7 +2056,7 @@ pub(crate) mod test {
        let addr = wallet.get_address(New).unwrap();
        let mut builder = wallet.build_tx();
        builder
-            .set_single_recipient(addr.script_pubkey())
+            .drain_to(addr.script_pubkey())
            .drain_wallet()
            .fee_absolute(0);
        let (psbt, details) = builder.finish().unwrap();
@@ -2081,7 +2076,7 @@ pub(crate) mod test {
        let addr = wallet.get_address(New).unwrap();
        let mut builder = wallet.build_tx();
        builder
-            .set_single_recipient(addr.script_pubkey())
+            .drain_to(addr.script_pubkey())
            .drain_wallet()
            .fee_absolute(60_000);
        let (_psbt, _details) = builder.finish().unwrap();
@@ -2122,13 +2117,13 @@ pub(crate) mod test {

    #[test]
    #[should_panic(expected = "InsufficientFunds")]
-    fn test_create_tx_single_recipient_dust_amount() {
+    fn test_create_tx_drain_to_dust_amount() {
        let (wallet, _, _) = get_funded_wallet(get_test_wpkh());
        let addr = wallet.get_address(New).unwrap();
        // very high fee rate, so that the only output would be below dust
        let mut builder = wallet.build_tx();
        builder
-            .set_single_recipient(addr.script_pubkey())
+            .drain_to(addr.script_pubkey())
            .drain_wallet()
            .fee_rate(FeeRate::from_sat_per_vb(453.0));
        builder.finish().unwrap();
@@ -2189,9 +2184,7 @@ pub(crate) mod test {
        let (wallet, _, _) = get_funded_wallet("wpkh([d34db33f/44'/0'/0']tpubDEnoLuPdBep9bzw5LoGYpsxUQYheRQ9gcgrJhJEcdKFB9cWQRyYmkCyRoTqeD4tJYiVVgt6A3rN6rWn9RYhR9sBsGxji29LYWHuKKbdb1ev/0/*)");
        let addr = wallet.get_address(New).unwrap();
        let mut builder = wallet.build_tx();
-        builder
-            .set_single_recipient(addr.script_pubkey())
-            .drain_wallet();
+        builder.drain_to(addr.script_pubkey()).drain_wallet();
        let (psbt, _) = builder.finish().unwrap();

        assert_eq!(psbt.inputs[0].bip32_derivation.len(), 1);
@@ -2215,9 +2208,7 @@ pub(crate) mod test {

        let addr = testutils!(@external descriptors, 5);
        let mut builder = wallet.build_tx();
-        builder
-            .set_single_recipient(addr.script_pubkey())
-            .drain_wallet();
+        builder.drain_to(addr.script_pubkey()).drain_wallet();
        let (psbt, _) = builder.finish().unwrap();

        assert_eq!(psbt.outputs[0].bip32_derivation.len(), 1);
@@ -2238,9 +2229,7 @@ pub(crate) mod test {
            get_funded_wallet("sh(pk(cVpPVruEDdmutPzisEsYvtST1usBR3ntr8pXSyt6D2YYqXRyPcFW))");
        let addr = wallet.get_address(New).unwrap();
        let mut builder = wallet.build_tx();
-        builder
-            .set_single_recipient(addr.script_pubkey())
-            .drain_wallet();
+        builder.drain_to(addr.script_pubkey()).drain_wallet();
        let (psbt, _) = builder.finish().unwrap();

        assert_eq!(
@@ -2263,9 +2252,7 @@ pub(crate) mod test {
            get_funded_wallet("wsh(pk(cVpPVruEDdmutPzisEsYvtST1usBR3ntr8pXSyt6D2YYqXRyPcFW))");
        let addr = wallet.get_address(New).unwrap();
        let mut builder = wallet.build_tx();
-        builder
-            .set_single_recipient(addr.script_pubkey())
-            .drain_wallet();
+        builder.drain_to(addr.script_pubkey()).drain_wallet();
        let (psbt, _) = builder.finish().unwrap();

        assert_eq!(psbt.inputs[0].redeem_script, None);
@@ -2288,9 +2275,7 @@ pub(crate) mod test {
            get_funded_wallet("sh(wsh(pk(cVpPVruEDdmutPzisEsYvtST1usBR3ntr8pXSyt6D2YYqXRyPcFW)))");
        let addr = wallet.get_address(New).unwrap();
        let mut builder = wallet.build_tx();
-        builder
-            .set_single_recipient(addr.script_pubkey())
-            .drain_wallet();
+        builder.drain_to(addr.script_pubkey()).drain_wallet();
        let (psbt, _) = builder.finish().unwrap();

        let script = Script::from(
@@ -2310,9 +2295,7 @@ pub(crate) mod test {
            get_funded_wallet("sh(pk(cVpPVruEDdmutPzisEsYvtST1usBR3ntr8pXSyt6D2YYqXRyPcFW))");
        let addr = wallet.get_address(New).unwrap();
        let mut builder = wallet.build_tx();
-        builder
-            .set_single_recipient(addr.script_pubkey())
-            .drain_wallet();
+        builder.drain_to(addr.script_pubkey()).drain_wallet();
        let (psbt, _) = builder.finish().unwrap();

        assert!(psbt.inputs[0].non_witness_utxo.is_some());
@@ -2326,7 +2309,7 @@ pub(crate) mod test {
        let addr = wallet.get_address(New).unwrap();
        let mut builder = wallet.build_tx();
        builder
-            .set_single_recipient(addr.script_pubkey())
+            .drain_to(addr.script_pubkey())
            .only_witness_utxo()
            .drain_wallet();
        let (psbt, _) = builder.finish().unwrap();
@@ -2341,9 +2324,7 @@ pub(crate) mod test {
            get_funded_wallet("sh(wpkh(cVpPVruEDdmutPzisEsYvtST1usBR3ntr8pXSyt6D2YYqXRyPcFW))");
        let addr = wallet.get_address(New).unwrap();
        let mut builder = wallet.build_tx();
-        builder
-            .set_single_recipient(addr.script_pubkey())
-            .drain_wallet();
+        builder.drain_to(addr.script_pubkey()).drain_wallet();
        let (psbt, _) = builder.finish().unwrap();

        assert!(psbt.inputs[0].witness_utxo.is_some());
@@ -2355,9 +2336,7 @@ pub(crate) mod test {
            get_funded_wallet("wsh(pk(cVpPVruEDdmutPzisEsYvtST1usBR3ntr8pXSyt6D2YYqXRyPcFW))");
        let addr = wallet.get_address(New).unwrap();
        let mut builder = wallet.build_tx();
-        builder
-            .set_single_recipient(addr.script_pubkey())
-            .drain_wallet();
+        builder.drain_to(addr.script_pubkey()).drain_wallet();
        let (psbt, _) = builder.finish().unwrap();

        assert!(psbt.inputs[0].non_witness_utxo.is_some());
@@ -2991,7 +2970,7 @@ pub(crate) mod test {
        let addr = Address::from_str("2N1Ffz3WaNzbeLFBb51xyFMHYSEUXcbiSoX").unwrap();
        let mut builder = wallet.build_tx();
        builder
-            .set_single_recipient(addr.script_pubkey())
+            .drain_to(addr.script_pubkey())
            .drain_wallet()
            .enable_rbf();
        let (psbt, mut original_details) = builder.finish().unwrap();
@@ -3015,7 +2994,7 @@ pub(crate) mod test {
        let mut builder = wallet.build_fee_bump(txid).unwrap();
        builder
            .fee_rate(FeeRate::from_sat_per_vb(2.5))
-            .maintain_single_recipient()
+            .allow_shrinking(addr.script_pubkey())
            .unwrap();
        let (psbt, details) = builder.finish().unwrap();

@@ -3035,7 +3014,7 @@ pub(crate) mod test {
        let addr = Address::from_str("2N1Ffz3WaNzbeLFBb51xyFMHYSEUXcbiSoX").unwrap();
        let mut builder = wallet.build_tx();
        builder
-            .set_single_recipient(addr.script_pubkey())
+            .drain_to(addr.script_pubkey())
            .drain_wallet()
            .enable_rbf();
        let (psbt, mut original_details) = builder.finish().unwrap();
@@ -3058,7 +3037,7 @@ pub(crate) mod test {

        let mut builder = wallet.build_fee_bump(txid).unwrap();
        builder
-            .maintain_single_recipient()
+            .allow_shrinking(addr.script_pubkey())
            .unwrap()
            .fee_absolute(300);
        let (psbt, details) = builder.finish().unwrap();
@@ -3089,7 +3068,7 @@ pub(crate) mod test {
        let addr = Address::from_str("2N1Ffz3WaNzbeLFBb51xyFMHYSEUXcbiSoX").unwrap();
        let mut builder = wallet.build_tx();
        builder
-            .set_single_recipient(addr.script_pubkey())
+            .drain_to(addr.script_pubkey())
            .add_utxo(outpoint)
            .unwrap()
            .manually_selected_only()
@@ -3118,7 +3097,7 @@ pub(crate) mod test {
        let mut builder = wallet.build_fee_bump(txid).unwrap();
        builder
            .drain_wallet()
-            .maintain_single_recipient()
+            .allow_shrinking(addr.script_pubkey())
            .unwrap()
            .fee_rate(FeeRate::from_sat_per_vb(5.0));
        let (_, details) = builder.finish().unwrap();
@@ -3133,7 +3112,7 @@ pub(crate) mod test {
        // them, and make sure that `bump_fee` doesn't try to add more. This fails because we've
        // told the wallet it's not allowed to add more inputs AND it can't reduce the value of the
        // existing output. In other words, bump_fee + manually_selected_only is always an error
-        // unless you've also set "maintain_single_recipient".
+        // unless you've also set "allow_shrinking" OR there is a change output.
        let incoming_txid = crate::populate_test_db!(
            wallet.database.borrow_mut(),
            testutils! (@tx ( (@external descriptors, 0) => 25_000 ) (@confirmations 1)),
@@ -3146,7 +3125,7 @@ pub(crate) mod test {
        let addr = Address::from_str("2N1Ffz3WaNzbeLFBb51xyFMHYSEUXcbiSoX").unwrap();
        let mut builder = wallet.build_tx();
        builder
-            .set_single_recipient(addr.script_pubkey())
+            .drain_to(addr.script_pubkey())
            .add_utxo(outpoint)
            .unwrap()
            .manually_selected_only()
@@ -3312,11 +3291,11 @@ pub(crate) mod test {
            Some(100),
        );

-        // initially make a tx without change by using `set_single_recipient`
+        // initially make a tx without change by using `drain_to`
        let addr = Address::from_str("2N1Ffz3WaNzbeLFBb51xyFMHYSEUXcbiSoX").unwrap();
        let mut builder = wallet.build_tx();
        builder
-            .set_single_recipient(addr.script_pubkey())
+            .drain_to(addr.script_pubkey())
            .add_utxo(OutPoint {
                txid: incoming_txid,
                vout: 0,
@@ -3344,7 +3323,7 @@ pub(crate) mod test {
            .set_tx(&original_details)
            .unwrap();

-        // now bump the fees without using `maintain_single_recipient`. the wallet should add an
+        // now bump the fees without using `allow_shrinking`. the wallet should add an
        // extra input and a change output, and leave the original output untouched
        let mut builder = wallet.build_fee_bump(txid).unwrap();
        builder.fee_rate(FeeRate::from_sat_per_vb(50.0));
@@ -3590,9 +3569,7 @@ pub(crate) mod test {
        let (wallet, _, _) = get_funded_wallet("wpkh(tprv8ZgxMBicQKsPd3EupYiPRhaMooHKUHJxNsTfYuScep13go8QFfHdtkG9nRkFGb7busX4isf6X9dURGCoKgitaApQ6MupRhZMcELAxTBRJgS/*)");
        let addr = wallet.get_address(New).unwrap();
        let mut builder = wallet.build_tx();
-        builder
-            .set_single_recipient(addr.script_pubkey())
-            .drain_wallet();
+        builder.drain_to(addr.script_pubkey()).drain_wallet();
        let (mut psbt, _) = builder.finish().unwrap();

        let finalized = wallet.sign(&mut psbt, Default::default()).unwrap();
@@ -3607,9 +3584,7 @@ pub(crate) mod test {
        let (wallet, _, _) = get_funded_wallet("wpkh([d34db33f/84h/1h/0h]tprv8ZgxMBicQKsPd3EupYiPRhaMooHKUHJxNsTfYuScep13go8QFfHdtkG9nRkFGb7busX4isf6X9dURGCoKgitaApQ6MupRhZMcELAxTBRJgS/*)");
        let addr = wallet.get_address(New).unwrap();
        let mut builder = wallet.build_tx();
-        builder
-            .set_single_recipient(addr.script_pubkey())
-            .drain_wallet();
+        builder.drain_to(addr.script_pubkey()).drain_wallet();
        let (mut psbt, _) = builder.finish().unwrap();

        let finalized = wallet.sign(&mut psbt, Default::default()).unwrap();
@@ -3624,9 +3599,7 @@ pub(crate) mod test {
        let (wallet, _, _) = get_funded_wallet("wpkh(tprv8ZgxMBicQKsPd3EupYiPRhaMooHKUHJxNsTfYuScep13go8QFfHdtkG9nRkFGb7busX4isf6X9dURGCoKgitaApQ6MupRhZMcELAxTBRJgS/44'/0'/0'/0/*)");
        let addr = wallet.get_address(New).unwrap();
        let mut builder = wallet.build_tx();
-        builder
-            .set_single_recipient(addr.script_pubkey())
-            .drain_wallet();
+        builder.drain_to(addr.script_pubkey()).drain_wallet();
        let (mut psbt, _) = builder.finish().unwrap();

        let finalized = wallet.sign(&mut psbt, Default::default()).unwrap();
@@ -3641,9 +3614,7 @@ pub(crate) mod test {
        let (wallet, _, _) = get_funded_wallet("sh(wpkh(tprv8ZgxMBicQKsPd3EupYiPRhaMooHKUHJxNsTfYuScep13go8QFfHdtkG9nRkFGb7busX4isf6X9dURGCoKgitaApQ6MupRhZMcELAxTBRJgS/*))");
        let addr = wallet.get_address(New).unwrap();
        let mut builder = wallet.build_tx();
-        builder
-            .set_single_recipient(addr.script_pubkey())
-            .drain_wallet();
+        builder.drain_to(addr.script_pubkey()).drain_wallet();
        let (mut psbt, _) = builder.finish().unwrap();

        let finalized = wallet.sign(&mut psbt, Default::default()).unwrap();
@@ -3659,9 +3630,7 @@ pub(crate) mod test {
            get_funded_wallet("wpkh(cVpPVruEDdmutPzisEsYvtST1usBR3ntr8pXSyt6D2YYqXRyPcFW)");
        let addr = wallet.get_address(New).unwrap();
        let mut builder = wallet.build_tx();
-        builder
-            .set_single_recipient(addr.script_pubkey())
-            .drain_wallet();
+        builder.drain_to(addr.script_pubkey()).drain_wallet();
        let (mut psbt, _) = builder.finish().unwrap();

        let finalized = wallet.sign(&mut psbt, Default::default()).unwrap();
@@ -3676,9 +3645,7 @@ pub(crate) mod test {
        let (wallet, _, _) = get_funded_wallet("wpkh(tprv8ZgxMBicQKsPd3EupYiPRhaMooHKUHJxNsTfYuScep13go8QFfHdtkG9nRkFGb7busX4isf6X9dURGCoKgitaApQ6MupRhZMcELAxTBRJgS/*)");
        let addr = wallet.get_address(New).unwrap();
        let mut builder = wallet.build_tx();
-        builder
-            .set_single_recipient(addr.script_pubkey())
-            .drain_wallet();
+        builder.drain_to(addr.script_pubkey()).drain_wallet();
        let (mut psbt, _) = builder.finish().unwrap();

        psbt.inputs[0].bip32_derivation.clear();
@@ -3760,7 +3727,7 @@ pub(crate) mod test {
        let addr = wallet.get_address(New).unwrap();
        let mut builder = wallet.build_tx();
        builder
-            .set_single_recipient(addr.script_pubkey())
+            .drain_to(addr.script_pubkey())
            .sighash(sighash)
            .drain_wallet();
        let (mut psbt, _) = builder.finish().unwrap();
--- a/src/wallet/tx_builder.rs
+++ b/src/wallet/tx_builder.rs
@@ -133,7 +133,7 @@ pub struct TxBuilder<'a, B, D, Cs, Ctx> {
 pub(crate) struct TxParams {
    pub(crate) recipients: Vec<(Script, u64)>,
    pub(crate) drain_wallet: bool,
-    pub(crate) single_recipient: Option<Script>,
+    pub(crate) drain_to: Option<Script>,
    pub(crate) fee_policy: Option<FeePolicy>,
    pub(crate) internal_policy_path: Option<BTreeMap<String, Vec<usize>>>,
    pub(crate) external_policy_path: Option<BTreeMap<String, Vec<usize>>>,
@@ -560,49 +560,81 @@ impl<'a, B, D: BatchDatabase, Cs: CoinSelectionAlgorithm<D>> TxBuilder<'a, B, D,
        self
    }

-    /// Set a single recipient that will get all the selected funds minus the fee. No change will
-    /// be created
+    /// Sets the address to *drain* excess coins to.
    ///
-    /// This method overrides any recipient set with [`set_recipients`](Self::set_recipients) or
-    /// [`add_recipient`](Self::add_recipient).
+    /// Usually, when there are excess coins they are sent to a change address generated by the
+    /// wallet. This option replaces the usual change address with an arbitrary `script_pubkey` of
+    /// your choosing. Just as with a change output, if the drain output is not needed (the excess
+    /// coins are too small) it will not be included in the resulting transaction. The only
+    /// difference is that it is valid to use `drain_to` without setting any ordinary recipients
+    /// with [`add_recipient`] (but it is perfectly fine to add recipients as well).
    ///
-    /// It can only be used in conjunction with [`drain_wallet`](Self::drain_wallet) to send the
-    /// entire content of the wallet (minus filters) to a single recipient or with a
-    /// list of manually selected UTXOs by enabling [`manually_selected_only`](Self::manually_selected_only)
-    /// and selecting them with or [`add_utxo`](Self::add_utxo).
+    /// When bumping the fees of a transaction made with this option, you probably want to
+    /// use [`allow_shrinking`] to allow this output to be reduced to pay for the extra fees.
    ///
-    /// When bumping the fees of a transaction made with this option, the user should remeber to
-    /// add [`maintain_single_recipient`](Self::maintain_single_recipient) to correctly update the
-    /// single output instead of adding one more for the change.
-    pub fn set_single_recipient(&mut self, recipient: Script) -> &mut Self {
-        self.params.single_recipient = Some(recipient);
-        self.params.recipients.clear();
-
+    /// # Example
+    ///
+    /// `drain_to` is very useful for draining all the coins in a wallet with [`drain_wallet`] to a
+    /// single address.
+    ///
+    /// ```
+    /// # use std::str::FromStr;
+    /// # use bitcoin::*;
+    /// # use bdk::*;
+    /// # use bdk::wallet::tx_builder::CreateTx;
+    /// # let to_address = Address::from_str("2N4eQYCbKUHCCTUjBJeHcJp9ok6J2GZsTDt").unwrap();
+    /// # let wallet = doctest_wallet!();
+    /// let mut tx_builder = wallet.build_tx();
+    ///
+    /// tx_builder
+    ///     // Spend all outputs in this wallet.
+    ///     .drain_wallet()
+    ///     // Send the excess (which is all the coins minus the fee) to this address.
+    ///     .drain_to(to_address.script_pubkey())
+    ///     .fee_rate(FeeRate::from_sat_per_vb(5.0))
+    ///     .enable_rbf();
+    /// let (psbt, tx_details) = tx_builder.finish()?;
+    /// # Ok::<(), bdk::Error>(())
+    /// ```
+    ///
+    /// [`allow_shrinking`]: Self::allow_shrinking
+    /// [`add_recipient`]: Self::add_recipient
+    /// [`drain_wallet`]: Self::drain_wallet
+    pub fn drain_to(&mut self, script_pubkey: Script) -> &mut Self {
+        self.params.drain_to = Some(script_pubkey);
        self
    }
 }

 // methods supported only by bump_fee
 impl<'a, B, D: BatchDatabase> TxBuilder<'a, B, D, DefaultCoinSelectionAlgorithm, BumpFee> {
-    /// Bump the fees of a transaction made with [`set_single_recipient`](Self::set_single_recipient)
+    /// Explicitly tells the wallet that it is allowed to reduce the fee of the output matching this
+    /// `script_pubkey` in order to bump the transaction fee. Without specifying this the wallet
+    /// will attempt to find a change output to shrink instead.
    ///
-    /// Unless extra inputs are specified with [`add_utxo`], this flag will make
-    /// `bump_fee` reduce the value of the existing output, or fail if it would be consumed
-    /// entirely given the higher new fee rate.
+    /// **Note** that the output may shrink to below the dust limit and therefore be removed. If it is
+    /// preserved then it is currently not guaranteed to be in the same position as it was
+    /// originally.
    ///
-    /// If extra inputs are added and they are not entirely consumed in fees, a change output will not
-    /// be added; the existing output will simply grow in value.
-    ///
-    /// Fails if the transaction has more than one outputs.
-    ///
-    /// [`add_utxo`]: Self::add_utxo
-    pub fn maintain_single_recipient(&mut self) -> Result<&mut Self, Error> {
-        let mut recipients = self.params.recipients.drain(..).collect::<Vec<_>>();
-        if recipients.len() != 1 {
-            return Err(Error::SingleRecipientMultipleOutputs);
+    /// Returns an `Err` if `script_pubkey` can't be found among the recipients of the
+    /// transaction we are bumping.
+    pub fn allow_shrinking(&mut self, script_pubkey: Script) -> Result<&mut Self, Error> {
+        match self
+            .params
+            .recipients
+            .iter()
+            .position(|(recipient_script, _)| *recipient_script == script_pubkey)
+        {
+            Some(position) => {
+                self.params.recipients.remove(position);
+                self.params.drain_to = Some(script_pubkey);
+                Ok(self)
+            }
+            None => Err(Error::Generic(format!(
+                "{} was not in the original transaction",
+                script_pubkey
+            ))),
        }
-        self.params.single_recipient = Some(recipients.pop().unwrap().0);
-        Ok(self)
    }
 }

--- a/src/wallet/verify.rs
+++ b/src/wallet/verify.rs
@@ -124,7 +124,6 @@ mod test {
        }
        fn setup<D: BatchDatabase, P: 'static + Progress>(
            &self,
-            _stop_gap: Option<usize>,
            _database: &mut D,
            _progress_update: P,
        ) -> Result<(), Error> {
Author	SHA1	Message	Date
rajarshimaitra	9e508748a3	Update CI blockchain tests (cherry picked from commit `10b53a56d7`)	2021-09-15 13:44:11 -07:00
rajarshimaitra	84b8579df5	Test refactor - Fix esplora module level feature flag - Move esplora blockchain tests to module, to cover for both variants (cherry picked from commit `8d1d92e71e`)	2021-09-15 13:44:09 -07:00
rajarshimaitra	7cb0116c44	Fix reqwest blockchain test - add back await_or_block! to bdk-macros - use await_or_block! in reqwest tests (cherry picked from commit `a41a0030dc`)	2021-09-15 13:44:06 -07:00
rajarshimaitra	6e12468b12	Update Cargo.toml - Changed to local bdk-macro - Added back tokio - Update esplora-reqwest and test-esplora feature guards (cherry picked from commit `2459740f72`)	2021-09-15 13:44:04 -07:00
Steve Myers	5694b98304	Bump version to 0.11.1-dev	2021-09-04 11:43:24 -07:00
Steve Myers	aa786fbb21	Bump version to 0.11.0	2021-09-04 10:46:03 -07:00
Steve Myers	8c570ae7eb	Update version in src/lib.rs	2021-09-04 10:45:18 -07:00
Steve Myers	56a7bc9874	Update changelog	2021-09-04 10:44:44 -07:00
Steve Myers	cf1815a1c0	Bump version to 0.11.0-rc.1	2021-08-30 10:27:24 -07:00
Steve Myers	721748e98f	Fix CHANGELOG after merging release/0.10.0 branch	2021-08-25 22:20:20 +02:00
Steve Myers	976e641ba6	Merge commit 'refs/pull/411/head' of github.com:bitcoindevkit/bdk	2021-08-25 21:55:43 +02:00
Thomas Eizinger	7117557dea	Add deprecation policy to CONTRIBUTING.md	2021-08-25 17:43:06 +02:00
Richard Ulrich	fa013aeb83	moving get_funded_wallet out of the test section to make it available for bdk-reserves	2021-08-25 11:18:50 +02:00
Steve Myers	38d1d0b0e2	Merge branch 'release/0.10.0'	2021-08-19 19:55:24 +02:00
Steve Myers	582d2f3814	Remove unneeded cache paths for test-blockchains CI job	2021-08-19 18:17:20 +02:00
Steve Myers	5e0011e1a8	Change dependencies bitcoincore-rpc to core-rpc, update bitcoin to ^0.27 and miniscript to ^6.0	2021-08-19 18:16:40 +02:00
Steve Myers	39d2bd0d21	Update dev-dependencies electrsd to 0.10	2021-08-19 18:13:50 +02:00
Steve Myers	0e10952b80	Merge commit 'refs/pull/409/head' of github.com:bitcoindevkit/bdk	2021-08-19 14:08:05 +02:00
Steve Myers	19d74955e2	Update Database BatchOperations flush() documentation	2021-08-19 13:56:38 +02:00
Steve Myers	73a7faf144	Remove unneeded cache paths for test-blockchains CI job	2021-08-18 09:10:47 +02:00
Steve Myers	ea56a87b4b	Change dependencies bitcoincore-rpc to core-rpc, update bitcoin to ^0.27 and miniscript to ^6.0	2021-08-17 22:52:17 +02:00
Steve Myers	67f5f45e07	Update dev-dependencies electrsd to 0.10	2021-08-17 22:51:40 +02:00
Alekos Filini	b8680b299d	Bump version to 0.10.1-dev	2021-08-09 17:00:05 +02:00
Alekos Filini	a5d3a4d31a	Bump version to 0.10.0	2021-08-09 14:58:32 +02:00
Alekos Filini	d03d3c0dbd	Update `bdk-macros`	2021-08-09 14:57:58 +02:00
Alekos Filini	9aba3196ff	Bump version of `bdk-macros` to `v0.5.0`	2021-08-09 14:57:06 +02:00
Alekos Filini	c8593ecf70	Update version in `src/lib.rs`	2021-08-09 14:56:22 +02:00
Alekos Filini	cbec0b0bcf	Update changelog	2021-08-09 14:55:17 +02:00
Tobin Harding	e80be49d1e	Disable default features for rocksdb In an effort to reduce the build times of `rocksdb` we can set `default-features` to false. Please note, the build speed up is minimil With default features: ``` cargo check --features compact_filters 890.91s user 47.62s system 352% cpu 4:26.55 total ``` Without default features: ``` cargo check --features compact_filters 827.07s user 47.63s system 352% cpu 4:08.39 total ``` Enable `snappy` since it seems like this is the current default compression algorithm, therefore this patch (hopefully) makes no changes to the usage of the `rocksdb` library in `bdk`. From the `rocksdb` code: ``` /// Sets the compression algorithm that will be used for compressing blocks. /// /// Default: `DBCompressionType::Snappy` (`DBCompressionType::None` if /// snappy feature is not enabled). /// /// # Examples /// /// ``` /// use rocksdb::{Options, DBCompressionType}; /// /// let mut opts = Options::default(); /// opts.set_compression_type(DBCompressionType::Snappy); /// ``` pub fn set_compression_type(&mut self, t: DBCompressionType) { .... ```	2021-08-04 10:22:08 +10:00
Riccardo Casatta	fe30716fa2	update CHANGELOG citing new flush method	2021-08-03 12:34:26 +02:00
Riccardo Casatta	e52550cfec	Add flush method to Database trait	2021-08-03 12:33:31 +02:00
Riccardo Casatta	f57c0ca98e	in tests enable daemons logging if log level is Debug	2021-08-03 12:15:16 +02:00
Alekos Filini	c54e1e9652	Bump version to 0.10.0-rc.1	2021-07-30 17:47:45 +02:00
Tobin Harding	5cdc5fb58a	Move estimate -> fee rate logic to esplora module Currently we have duplicate code for converting the fee estimate we get back from esplora into a fee rate. This logic can be moved to a separate function and live in the `esplora` module.	2021-07-29 10:12:19 +10:00
Tobin Harding	27cd9bbcd6	Improve feature combinations for ureq/reqwest Our features are a bit convoluted, most annoyingly we cannot build with `--all-features`. However we can make life for users a little easier. Explicitly we want users to be able to: - Use async-interface/WASM without using esplora (to implement their own blockchain) - Use esplora in an ergonomic manner Currently using esplora requires either reqwest or ureq. Instead of making the user add all the features manually we can add features that add the required feature sets, this makes it easier for users to understand what is required and also makes usage easier. With this patch applied we can do - `cargo check --no-default-features --features=use-esplora-reqwest` - `cargo check --no-default-features --features=use-esplora-ureq` - `cargo check --features=use-esplora-ureq` - `cargo check --no-default-features --features=async-trait`	2021-07-29 10:12:17 +10:00
Tobin Harding	f37e735b43	Add a ureq version of esplora module The `Blockchain` implementation for connecting to an Esplora instance is currently based on `reqwest`. Some users may not wish to use reqwest. `ureq` is a simple HTTP client (no async) that is useful when `reqwest` is not suitable. - Move `esplora.rs` -> `esplora/reqwest.rs` - Add an implementation based on the `reqwest` esplora code but using `ureq` - Add feature flags and conditional includes to re-export everything to the `esplora` module so we don't effect the rest of the code base. - Remove the forced dependency on `tokio`. - Make esplora independent of async-interface - Depend on local version of macros crate	2021-07-29 09:16:44 +10:00
codeShark149	adceafa40c	Fix float substraction error	2021-07-28 11:52:51 +02:00
Alekos Filini	2b0c4f0817	Merge commit 'refs/pull/407/head' of github.com:bitcoindevkit/bdk	2021-07-28 11:34:41 +02:00
Alekos Filini	e9428433a0	Merge commit 'refs/pull/408/head' of github.com:bitcoindevkit/bdk	2021-07-28 11:32:44 +02:00
Alekos Filini	63592f169f	Merge commit 'refs/pull/392/head' of github.com:bitcoindevkit/bdk	2021-07-27 13:23:25 +02:00
Alekos Filini	27600f4a11	Merge commit 'refs/pull/398/head' of github.com:bitcoindevkit/bdk	2021-07-27 13:07:56 +02:00
Riccardo Casatta	77eae76459	add link to upstream PR	2021-07-27 12:17:12 +02:00
Riccardo Casatta	ad69702aa3	Update electrsd dep	2021-07-26 17:09:00 +02:00
Riccardo Casatta	fd254536d3	update CHANGELOG.md	2021-07-26 16:36:35 +02:00
Riccardo Casatta	c4d5dd14fa	Use RPC backend in any	2021-07-26 16:36:32 +02:00
Riccardo Casatta	13bed2667a	Create Auth struct proxy of the same upstream struct but serializable	2021-07-26 15:55:40 +02:00
Tobin Harding	2db24fb8c5	Add unit test required not enough Add a unit test that passes a required utxo to the coin selection algorithm that is less than the required spend. This tests that we get that utxo included as well as tests that the rest of the coin selection algorithm code also executes (i.e., that we do not short circuit incorrectly).	2021-07-23 10:27:16 +10:00
Tobin Harding	d2d37fc06d	Return early if required UTXOs already big enough If the required UTXO set is already bigger (including fees) than the amount required for the transaction we can return early, no need to go through the BNB algorithm or random selection.	2021-07-23 09:48:22 +10:00
Tobin Harding	2986fce7c6	Fix vbytes and fee rate code It was just pointed out that we are calculating the virtual bytes incorrectly by forgetting to take the ceiling after division by 4 [1] Add helper functions to encapsulate all weight unit -> virtual byte calculations including fee to and from fee rate. This makes the code easier to read, easier to write, and gives us a better chance that bugs like this will be easier to see. As an added bonus we can also stop using f32 values for fee amount, which is by definition an amount in sats so should be a u64. This removes a bunch of casts and the need for epsilon comparisons and just deep down feels nice :) [1] https://github.com/bitcoindevkit/bdk/pull/386#discussion_r670882678	2021-07-23 09:43:12 +10:00
Roman Zeyde	1dc648508c	Fix a small typo in comments	2021-07-21 21:32:35 +03:00
Steve Myers	474620e6a5	[keys] limit version of zeroize to support rust 1.47+	2021-07-19 14:35:16 -07:00
Steve Myers	a5919f4ab0	Remove stop_gap param from Blockchain trait setup and sync functions	2021-07-16 08:52:41 -07:00
Steve Myers	7e986fd904	Add stop_gap param to electrum and esplora blockchain configs	2021-07-16 08:50:36 -07:00
Alekos Filini	77379e9262	Merge commit 'refs/pull/371/head' of github.com:bitcoindevkit/bdk	2021-07-16 11:24:19 +02:00
Alekos Filini	ea699a6ec1	Merge commit 'refs/pull/393/head' of github.com:bitcoindevkit/bdk	2021-07-16 09:05:51 +02:00
Lloyd Fournier	81c1ccb185	Apply typo fixes from @tcharding Co-authored-by: Tobin C. Harding <me@tobin.cc>	2021-07-14 16:43:02 +10:00
Steve Myers	4f4802b0f3	Merge commit 'refs/pull/388/head' of github.com:bitcoindevkit/bdk	2021-07-13 16:10:30 -07:00
Steve Myers	bab9d99a00	Merge commit 'refs/pull/375/head' of github.com:bitcoindevkit/bdk	2021-07-13 15:12:53 -07:00
Alekos Filini	22f4db0de1	Merge commit 'refs/pull/389/head' of github.com:bitcoindevkit/bdk	2021-07-12 14:26:05 +02:00
Riccardo Casatta	a6ce75fa2d	[docs] clarify when the fee could be unknown	2021-07-12 10:06:08 +02:00
LLFourn	7597645ed6	Replace set_single_recipient with drain_to What set_single_recipient does turns out to be useful with multiple recipients. Effectively, set_single_recipient was simply creating a change output that was arbitrarily required to be the only output. But what if you want to send excess funds to one address but still have additional recipients who receive a fixed value? Generalizing this to `drain_to` simplifies the logic and removes several error cases while also allowing new use cases. "maintain_single_recipient" is also replaced with "allow_shrinking" which has more general semantics.	2021-07-12 16:38:42 +10:00
LLFourn	618e0d3700	Replace set_single_recipient with drain_to What set_single_recipient does turns out to be useful with multiple recipients. Effectively, set_single_recipient was simply creating a change output that was arbitrarily required to be the only output. But what if you want to send excess funds to one address but still have additional recipients who receive a fixed value? Generalizing this to `drain_to` simplifies the logic and removes several error cases while also allowing new use cases. "maintain_single_recipient" is also replaced with "allow_shrinking" which has more general semantics.	2021-07-12 16:21:53 +10:00
Alekos Filini	44d0e8d07c	[rpc] Show in the docs that the RPC APIs are feature-gated	2021-07-09 09:11:02 +02:00
Alekos Filini	7a9b691f68	Bump version to 0.9.1-dev	2021-07-08 15:20:28 +02:00
Tobin Harding	c1077b95cf	Add Vbytes trait We convert weight units into vbytes in various places. Lets add a trait to do it, this makes the code slightly cleaner.	2021-07-08 11:33:39 +10:00
Alekos Filini	e5d4994329	Merge commit 'refs/pull/383/head' of github.com:bitcoindevkit/bdk	2021-07-06 09:58:22 +02:00
Riccardo Casatta	7109f7d9b4	fix readme	2021-06-29 11:35:02 +02:00
Riccardo Casatta	f52fda4b4b	update github ci removing electrs download and fixing cache	2021-06-29 11:35:00 +02:00
Riccardo Casatta	a6be470fe4	use electrsd with feature to download the binary	2021-06-29 11:34:58 +02:00
Riccardo Casatta	8e41c4587d	use bitcoind with feature to download the binary	2021-06-29 11:34:56 +02:00
Riccardo Casatta	2ecae348ea	use cfg! instead of #[cfg] and use semver	2021-06-29 11:34:54 +02:00
Riccardo Casatta	f4ecfa0d49	Remove container and test blockchains downloading backends executables	2021-06-29 11:34:48 +02:00
Riccardo Casatta	696647b893	trigger electrs when polling	2021-06-29 11:32:30 +02:00
Riccardo Casatta	18dcda844f	remove serial_test	2021-06-29 11:32:28 +02:00
Riccardo Casatta	6394c3e209	use bitcoind and electrsd crate to launch daemons	2021-06-29 11:32:26 +02:00
Riccardo Casatta	42adad7dbd	bump bitcoind dep to 0.11.0	2021-06-29 11:32:24 +02:00
Alekos Filini	4498e0f7f8	[testutils] Allow the generated blockchain tests to access `test_client`	2021-06-29 11:32:20 +02:00