Bump version to 0.25.0

b5fcddcf1a Add sqlite migration to drop duplicated script_pubkeys rows (Steve Myers)
21c96c9c81 Add test for issue #801 (Alekos Filini)
c51d544932 [wip] Ensure there are no duplicated script_pubkeys in sqlite (Alekos Filini)

Pull request description:

  ### Description

  Add a `UNIQUE` constraint on the script_pubkeys table so that it doesn't grow constantly when caching new addresses.

  Fixes #801

  ### Notes to the reviewers

  Adding it to the 0.25 milestone since it's just a bugfix.

  Still in draft because I need to add extra migration queries to clean up existing dbs.

  ### Checklists

  #### All Submissions:

  * [x] I've signed all my commits
  * [x] I followed the [contribution guidelines](https://github.com/bitcoindevkit/bdk/blob/master/CONTRIBUTING.md)
  * [x] I ran `cargo fmt` and `cargo clippy` before committing

  #### Bugfixes:

  * [ ] This pull request breaks the existing API
  * [x] I've added tests to reproduce the issue which are now passing
  * [x] I'm linking the issue being fixed by this PR

ACKs for top commit:
  notmandatory:
    ACK b5fcddcf1a

Tree-SHA512: 7b10e453bb38af5c4f80f77692a56e37259680e50f9c2c9e554a0e5f04fb9cab897da6476c6c9930f1c501b455472984a1c92c4f137cff49acdc390d2e705107

.github/ISSUE_TEMPLATE/enhancement_request.md

@@ -0,0 +1,17 @@
+---
+name: Enhancement request
+about: Request a new feature or change to an existing feature
+title: ''
+labels: 'enhancement'
+assignees: ''
+
+---
+
+**Describe the enhancement**  
+<!-- A clear and concise description of what you would like added or changed. -->
+
+**Use case**  
+<!-- Tell us how you or others will use this new feature or change to an existing feature. --> 
+
+**Additional context**
+<!-- Add any other context about the enhancement here. --> 

.github/ISSUE_TEMPLATE/minor_release.md

@@ -21,9 +21,9 @@ assignees: ''
 
 <--add notices from PRs merged since the prior release, see ["keep a changelog"]-->
 
-### Checklist 
+### Checklist
 
-Release numbering must follow [Semantic Versioning]. These steps assume the current `master` 
+Release numbering must follow [Semantic Versioning]. These steps assume the current `master`
 branch **development** version is *MAJOR.MINOR.0*.
 
 #### On the day of the feature freeze
@@ -37,34 +37,43 @@ Change the `master` branch to the next MINOR+1 version:
   - The commit message should be "Bump version to MAJOR.MINOR+1.0".
 - [ ] Create PR and merge the `bump_dev_MAJOR_MINOR+1` branch to `master`.
   - Title PR "Bump version to MAJOR.MINOR+1.0".
-  
+
 Create a new release branch and release candidate tag:
 
 - [ ] Double check that your local `master` is up-to-date with the upstream repo.
 - [ ] Create a new branch called `release/MAJOR.MINOR+1` from `master`.
+- [ ] Bump the `release/MAJOR.MINOR+1` branch to `MAJOR.MINOR+1.0-rc.1` version.
+  - Change the `Cargo.toml` version value to `MAJOR.MINOR+1.0-rc.1`.
+  - The commit message should be "Bump version to MAJOR.MINOR+1.0-rc.1".
 - [ ] Add a tag to the `HEAD` commit in the `release/MAJOR.MINOR+1` branch.
-  - The tag name should be `vMAJOR.MINOR+1.0-RC.1`
-  - Use message "Release MAJOR.MINOR+1.0 RC.1".  
+  - The tag name should be `vMAJOR.MINOR+1.0-rc.1`
+  - Use message "Release MAJOR.MINOR+1.0 rc.1".
   - Make sure the tag is signed, for extra safety use the explicit `--sign` flag.
 - [ ] Push the `release/MAJOR.MINOR` branch and new tag to the `bitcoindevkit/bdk` repo.
-  - Use `git push --tags` option to push the new `vMAJOR.MINOR+1.0-RC.1` tag.
-  
+  - Use `git push --tags` option to push the new `vMAJOR.MINOR+1.0-rc.1` tag.
+
 If any issues need to be fixed before the *MAJOR.MINOR+1.0* version is released:
 
 - [ ] Merge fix PRs to the `master` branch.
 - [ ] Git cherry-pick fix commits to the `release/MAJOR.MINOR+1` branch.
 - [ ] Verify fixes in `release/MAJOR.MINOR+1` branch.
+- [ ] Bump the `release/MAJOR.MINOR+1` branch to `MAJOR.MINOR+1.0-rc.x+1` version.
+  - Change the `Cargo.toml` version value to `MAJOR.MINOR+1.0-rc.x+1`.
+  - The commit message should be "Bump version to MAJOR.MINOR+1.0-rc.x+1".
 - [ ] Add a tag to the `HEAD` commit in the `release/MAJOR.MINOR+1` branch.
-  - The tag name should be `vMAJOR.MINOR+1.0-RC.x+1`, where x is the current release candidate number.
-  - Use tag message "Release MAJOR.MINOR+1.0 RC.x+1".  
+  - The tag name should be `vMAJOR.MINOR+1.0-rc.x+1`, where x is the current release candidate number.
+  - Use tag message "Release MAJOR.MINOR+1.0 rc.x+1".
   - Make sure the tag is signed, for extra safety use the explicit `--sign` flag.
 - [ ] Push the new tag to the `bitcoindevkit/bdk` repo.
-  - Use `git push --tags` option to push the new `vMAJOR.MINOR+1.0-RC.x+1` tag.
+  - Use `git push --tags` option to push the new `vMAJOR.MINOR+1.0-rc.x+1` tag.
 
 #### On the day of the release
 
 Tag and publish new release:
 
+- [ ] Bump the `release/MAJOR.MINOR+1` branch to `MAJOR.MINOR+1.0` version.
+  - Change the `Cargo.toml` version value to `MAJOR.MINOR+1.0`.
+  - The commit message should be "Bump version to MAJOR.MINOR+1.0".
 - [ ] Add a tag to the `HEAD` commit in the `release/MAJOR.MINOR+1` branch.
   - The tag name should be `vMAJOR.MINOR+1.0`
   - The first line of the tag message should be "Release MAJOR.MINOR+1.0".

.github/ISSUE_TEMPLATE/patch_release.md

@@ -21,9 +21,9 @@ assignees: ''
 
 <--add notices from PRs merged since the prior release, see ["keep a changelog"]-->
 
-### Checklist  
+### Checklist
 
-Release numbering must follow [Semantic Versioning]. These steps assume the current `master` 
+Release numbering must follow [Semantic Versioning]. These steps assume the current `master`
 branch **development** version is *MAJOR.MINOR.PATCH*.
 
 ### On the day of the patch release
@@ -43,6 +43,9 @@ Cherry-pick, tag and publish new PATCH+1 release:
 - [ ] Merge fix PRs to the `master` branch.
 - [ ] Git cherry-pick fix commits to the `release/MAJOR.MINOR` branch to be patched.
 - [ ] Verify fixes in `release/MAJOR.MINOR` branch.
+- [ ] Bump the `release/MAJOR.MINOR.PATCH+1` branch to `MAJOR.MINOR.PATCH+1` version.
+  - Change the `Cargo.toml` version value to `MAJOR.MINOR.MINOR.PATCH+1`.
+  - The commit message should be "Bump version to MAJOR.MINOR.PATCH+1".
 - [ ] Add a tag to the `HEAD` commit in the `release/MAJOR.MINOR` branch.
   - The tag name should be `vMAJOR.MINOR.PATCH+1`
   - The first line of the tag message should be "Release MAJOR.MINOR.PATCH+1".

.github/workflows/code_coverage.yml

@@ -1,37 +1,61 @@
-on: [push]
+on: [push, pull_request]
 
 name: Code Coverage
 
 jobs:
-
   Codecov:
     name: Code Coverage
     runs-on: ubuntu-latest
     env:
-      CARGO_INCREMENTAL: '0'
-      RUSTFLAGS: '-Zprofile -Ccodegen-units=1 -Cinline-threshold=0 -Clink-dead-code -Coverflow-checks=off'
-      RUSTDOCFLAGS: '-Zprofile -Ccodegen-units=1 -Cinline-threshold=0 -Clink-dead-code -Coverflow-checks=off'
+      RUSTFLAGS: "-Cinstrument-coverage"
+      RUSTDOCFLAGS: "-Cinstrument-coverage"
+      LLVM_PROFILE_FILE: "report-%p-%m.profraw"
 
     steps:
       - name: Checkout
         uses: actions/checkout@v2
+      - name: Install lcov tools
+        run: sudo apt-get install lcov -y
       - name: Install rustup
         run: curl https://sh.rustup.rs -sSf | sh -s -- -y
       - name: Set default toolchain
         run: rustup default nightly
       - name: Set profile
         run: rustup set profile minimal
+      - name: Add llvm tools
+        run: rustup component add llvm-tools-preview
       - name: Update toolchain
         run: rustup update
-      - name: Test
-        run: cargo test --features all-keys,compiler,esplora,ureq,compact_filters --no-default-features
-                    
-      - id: coverage
-        name: Generate coverage
-        uses: actions-rs/grcov@v0.1.5
-
-      - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v2
+      - name: Cache cargo
+        uses: actions/cache@v3
         with:
-          file: ${{ steps.coverage.outputs.report }}
-          directory: ./coverage/reports/
+          path: |
+            ~/.cargo/bin/
+            ~/.cargo/registry/index/
+            ~/.cargo/registry/cache/
+            ~/.cargo/git/db/
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+      - name: Install grcov
+        run: if [[ ! -e ~/.cargo/bin/grcov ]]; then cargo install grcov; fi
+      - name: Test
+        # WARNING: this is not testing the following features: test-esplora, test-hardware-signer, async-interface
+        # This is because some of our features are mutually exclusive, and generating various reports and
+        # merging them doesn't seem to be working very well.
+        # For more info, see:
+        # - https://github.com/bitcoindevkit/bdk/issues/696
+        # - https://github.com/bitcoindevkit/bdk/pull/748#issuecomment-1242721040
+        run: cargo test --features all-keys,compact_filters,compiler,key-value-db,sqlite,sqlite-bundled,test-electrum,test-rpc,verify
+      - name: Run grcov
+        run: mkdir coverage; grcov . --binary-path ./target/debug/ -s . -t lcov --branch --ignore-not-existing --ignore '/*' -o ./coverage/lcov.info
+      - name: Generate HTML coverage report
+        run: genhtml -o coverage-report.html ./coverage/lcov.info
+
+      - name: Coveralls upload
+        uses: coverallsapp/github-action@master
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+      - name: Upload artifact
+        uses: actions/upload-artifact@v2
+        with:
+          name: coverage-report
+          path: coverage-report.html

.github/workflows/cont_integration.yml

@@ -17,16 +17,16 @@ jobs:
           - default
           - minimal
           - all-keys
-          - minimal,use-esplora-ureq
+          - minimal,use-esplora-blocking
           - key-value-db
           - electrum
           - compact_filters
-          - esplora,ureq,key-value-db,electrum
+          - use-esplora-blocking,key-value-db,electrum
           - compiler
           - rpc
           - verify
           - async-interface
-          - use-esplora-reqwest
+          - use-esplora-async
           - sqlite
           - sqlite-bundled
     steps:
@@ -100,10 +100,10 @@ jobs:
             features: test-rpc-legacy
           - name: esplora
             testprefix: esplora
-            features: test-esplora,use-esplora-reqwest,verify
+            features: test-esplora,use-esplora-async,verify
           - name: esplora
             testprefix: esplora
-            features: test-esplora,use-esplora-ureq,verify
+            features: test-esplora,use-esplora-blocking,verify
     steps:
       - name: Checkout
         uses: actions/checkout@v2
@@ -154,7 +154,7 @@ jobs:
       - name: Update toolchain
         run: rustup update
       - name: Check
-        run: cargo check --target wasm32-unknown-unknown --features use-esplora-reqwest --no-default-features
+        run: cargo check --target wasm32-unknown-unknown --features use-esplora-async,dev-getrandom-wasm --no-default-features
 
   fmt:
     name: Rust fmt
@@ -173,8 +173,8 @@ jobs:
       - name: Check fmt
         run: cargo fmt --all -- --config format_code_in_doc_comments=true --check
 
-  test_harware_wallet:
-    runs-on: ubuntu-latest
+  test_hardware_wallet:
+    runs-on: ubuntu-20.04
     strategy:
       matrix:
         rust:

.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,ureq,compact_filters,key-value-db,all-keys,sqlite -- --cfg docsrs -Dwarnings
+        run: cargo rustdoc --verbose --features=compiler,electrum,esplora,use-esplora-blocking,compact_filters,rpc,key-value-db,sqlite,all-keys,verify,hardware-signer -- --cfg docsrs -Dwarnings
       - name: Upload artifact
         uses: actions/upload-artifact@v2
         with:

.gitignore

@@ -1,5 +1,6 @@
 /target
 Cargo.lock
+/.vscode
 
 *.swp
 .idea

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bdk"
-version = "0.21.0"
+version = "0.25.0"
 edition = "2018"
 authors = ["Alekos Filini <alekos.filini@gmail.com>", "Riccardo Casatta <riccardo@casatta.it>"]
 homepage = "https://bitcoindevkit.org"
@@ -14,41 +14,39 @@ license = "MIT OR Apache-2.0"
 [dependencies]
 bdk-macros = "^0.6"
 log = "^0.4"
-miniscript = { version = "7.0", features = ["use-serde"] }
-bitcoin = { version = "0.28.1", features = ["use-serde", "base64", "rand"] }
+miniscript = { version = "8.0", features = ["serde"] }
+bitcoin = { version = "0.29.1", features = ["serde", "base64", "rand"] }
 serde = { version = "^1.0", features = ["derive"] }
 serde_json = { version = "^1.0" }
-rand = "^0.7"
+rand = "^0.8"
 
 # Optional dependencies
 sled = { version = "0.34", optional = true }
-electrum-client = { version = "0.10", optional = true }
+electrum-client = { version = "0.12", optional = true }
+esplora-client = { version = "0.2", default-features = false, optional = true }
 rusqlite = { version = "0.27.0", optional = true }
 ahash = { version = "0.7.6", optional = true }
-reqwest = { version = "0.11", optional = true, default-features = false, features = ["json"] }
-ureq = { version = "~2.2.0", features = ["json"], optional = true }
 futures = { version = "0.3", optional = true }
 async-trait = { version = "0.1", 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 }
-hwi = { version = "0.2.2", optional = true }
+hwi = { version = "0.3.0", optional = true }
 
 bip39 = { version = "1.0.1", optional = true }
 bitcoinconsensus = { version = "0.19.0-3", optional = true }
 
 # Needed by bdk_blockchain_tests macro and the `rpc` feature
-bitcoincore-rpc = { version = "0.15", optional = true }
+bitcoincore-rpc = { version = "0.16", optional = true }
 
 # Platform-specific dependencies
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-tokio = { version = "1", features = ["rt"] }
+tokio = { version = "1", features = ["rt", "macros"] }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
+getrandom = "0.2"
 async-trait = "0.1"
 js-sys = "0.3"
-rand = { version = "^0.7", features = ["wasm-bindgen"] }
 
 [features]
 minimal = []
@@ -57,7 +55,7 @@ verify = ["bitcoinconsensus"]
 default = ["key-value-db", "electrum"]
 sqlite = ["rusqlite", "ahash"]
 sqlite-bundled = ["sqlite", "rusqlite/bundled"]
-compact_filters = ["rocksdb", "socks", "lazy_static", "cc"]
+compact_filters = ["rocksdb", "socks", "cc"]
 key-value-db = ["sled"]
 all-keys = ["keys-bip39"]
 keys-bip39 = ["bip39"]
@@ -70,23 +68,26 @@ hardware-signer = ["hwi"]
 #
 # - 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`).
+#   enable the `use-esplora-async` feature.
 # - 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`).
+#   use Esplora should enable the `use-esplora-blocking` feature.
 #
 # 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", "reqwest/socks", "futures"]
-use-esplora-ureq = ["esplora", "ureq", "ureq/socks"]
+use-esplora-async = ["esplora", "esplora-client/async", "futures"]
+use-esplora-blocking = ["esplora", "esplora-client/blocking"]
+# Deprecated aliases
+use-esplora-reqwest = ["use-esplora-async"]
+use-esplora-ureq = ["use-esplora-blocking"]
 # Typical configurations will not need to use `esplora` feature directly.
 esplora = []
 
-# Use below feature with `use-esplora-reqwest` to enable reqwest default TLS support
-reqwest-default-tls = ["reqwest/default-tls"]
+# Use below feature with `use-esplora-async` to enable reqwest default TLS support
+reqwest-default-tls = ["esplora-client/async-https"]
 
 # Debug/Test features
 test-blockchains = ["bitcoincore-rpc", "electrum-client"]
@@ -97,14 +98,18 @@ test-esplora = ["electrsd/legacy", "electrsd/esplora_a33e97e1", "electrsd/bitcoi
 test-md-docs = ["electrum"]
 test-hardware-signer = ["hardware-signer"]
 
+# This feature is used to run `cargo check` in our CI targeting wasm. It's not recommended
+# for libraries to explicitly include the "getrandom/js" feature, so we only do it when
+# necessary for running our CI. See: https://docs.rs/getrandom/0.2.8/getrandom/#webassembly-support
+dev-getrandom-wasm = ["getrandom/js"]
+
 [dev-dependencies]
 lazy_static = "1.4"
 env_logger = "0.7"
-clap = "2.33"
-electrsd = "0.19.1"
+electrsd = "0.21"
+# Move back to importing from rust-bitcoin once https://github.com/rust-bitcoin/rust-bitcoin/pull/1342 is released
+base64 = "^0.13"
 
-[[example]]
-name = "address_validator"
 [[example]]
 name = "compact_filters_balance"
 required-features = ["compact_filters"]
@@ -114,14 +119,48 @@ name = "miniscriptc"
 path = "examples/compiler.rs"
 required-features = ["compiler"]
 
+[[example]]
+name = "policy"
+path = "examples/policy.rs"
+
 [[example]]
 name = "rpcwallet"
 path = "examples/rpcwallet.rs"
 required-features = ["keys-bip39", "key-value-db", "rpc", "electrsd/bitcoind_22_0"]
 
+[[example]]
+name = "psbt_signer"
+path = "examples/psbt_signer.rs"
+required-features = ["electrum"]
+
+[[example]]
+name = "hardware_signer"
+path = "examples/hardware_signer.rs"
+required-features = ["electrum", "hardware-signer"]
+
+[[example]]
+name = "electrum_backend"
+path = "examples/electrum_backend.rs"
+required-features = ["electrum"]
+
+[[example]]
+name = "esplora_backend_synchronous"
+path = "examples/esplora_backend_synchronous.rs"
+required-features = ["use-esplora-ureq"]
+
+[[example]]
+name = "esplora_backend_asynchronous"
+path = "examples/esplora_backend_asynchronous.rs"
+required-features = ["use-esplora-reqwest", "reqwest-default-tls", "async-interface"]
+
+[[example]]
+name = "mnemonic_to_descriptors"
+path = "examples/mnemonic_to_descriptors.rs"
+required-features = ["all-keys"]
+
 [workspace]
 members = ["macros"]
 [package.metadata.docs.rs]
-features = ["compiler", "electrum", "esplora", "use-esplora-ureq", "compact_filters", "rpc", "key-value-db", "sqlite", "all-keys", "verify", "hardware-signer"]
+features = ["compiler", "electrum", "esplora", "use-esplora-blocking", "compact_filters", "rpc", "key-value-db", "sqlite", "all-keys", "verify", "hardware-signer"]
 # defines the configuration attribute `docsrs`
 rustdoc-args = ["--cfg", "docsrs"]

README.md

@@ -11,7 +11,7 @@
     <a href="https://crates.io/crates/bdk"><img alt="Crate Info" src="https://img.shields.io/crates/v/bdk.svg"/></a>
     <a href="https://github.com/bitcoindevkit/bdk/blob/master/LICENSE"><img alt="MIT or Apache-2.0 Licensed" src="https://img.shields.io/badge/license-MIT%2FApache--2.0-blue.svg"/></a>
     <a href="https://github.com/bitcoindevkit/bdk/actions?query=workflow%3ACI"><img alt="CI Status" src="https://github.com/bitcoindevkit/bdk/workflows/CI/badge.svg"></a>
-    <a href="https://codecov.io/gh/bitcoindevkit/bdk"><img src="https://codecov.io/gh/bitcoindevkit/bdk/branch/master/graph/badge.svg"/></a>
+    <a href="https://coveralls.io/github/bitcoindevkit/bdk?branch=master"><img src="https://coveralls.io/repos/github/bitcoindevkit/bdk/badge.svg?branch=master"/></a>
     <a href="https://docs.rs/bdk"><img alt="API Docs" src="https://img.shields.io/badge/docs.rs-bdk-green"/></a>
     <a href="https://blog.rust-lang.org/2021/11/01/Rust-1.56.1.html"><img alt="Rustc Version 1.56.1+" src="https://img.shields.io/badge/rustc-1.56.1%2B-lightgrey.svg"/></a>
     <a href="https://discord.gg/d7NkDKm"><img alt="Chat on Discord" src="https://img.shields.io/discord/753336465005608961?logo=discord"></a>
@@ -95,7 +95,7 @@ use bdk::blockchain::ElectrumBlockchain;
 use bdk::electrum_client::Client;
 use bdk::wallet::AddressIndex::New;
 
-use bitcoin::base64;
+use base64;
 use bitcoin::consensus::serialize;
 
 fn main() -> Result<(), bdk::Error> {
@@ -132,7 +132,7 @@ fn main() -> Result<(), bdk::Error> {
 ```rust,no_run
 use bdk::{Wallet, SignOptions, database::MemoryDatabase};
 
-use bitcoin::base64;
+use base64;
 use bitcoin::consensus::deserialize;
 
 fn main() -> Result<(), bdk::Error> {
@@ -171,6 +171,17 @@ cargo test --features test-electrum
 The other options are `test-esplora`, `test-rpc` or `test-rpc-legacy` which runs against an older version of Bitcoin Core.
 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.
 
+## Running under WASM
+
+If you want to run this library under WASM you will probably have to add the following lines to you `Cargo.toml`:
+
+```toml
+[dependencies]
+getrandom = { version = "0.2", features = ["js"] }
+```
+
+This enables the `rand` crate to work in environments where JavaScript is available. See [this link](https://docs.rs/getrandom/0.2.8/getrandom/#webassembly-support) to learn more.
+
 ## License
 
 Licensed under either of

codecov.yaml

@@ -1,13 +0,0 @@
-coverage:
-  status:
-    project:
-      default:
-        target: auto
-        threshold: 1%
-        base: auto
-        informational: false
-    patch:
-      default:
-        target: auto
-        threshold: 100%
-        base: auto

examples/address_validator.rs

@@ -1,63 +0,0 @@
-// Bitcoin Dev Kit
-// Written in 2020 by Alekos Filini <alekos.filini@gmail.com>
-//
-// Copyright (c) 2020-2021 Bitcoin Dev Kit Developers
-//
-// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
-// or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
-// You may not use this file except in accordance with one or both of these
-// licenses.
-
-use std::sync::Arc;
-
-use bdk::bitcoin;
-use bdk::database::MemoryDatabase;
-use bdk::descriptor::HdKeyPaths;
-#[allow(deprecated)]
-use bdk::wallet::address_validator::{AddressValidator, AddressValidatorError};
-use bdk::KeychainKind;
-use bdk::Wallet;
-
-use bdk::wallet::AddressIndex::New;
-use bitcoin::hashes::hex::FromHex;
-use bitcoin::util::bip32::Fingerprint;
-use bitcoin::{Network, Script};
-
-#[derive(Debug)]
-struct DummyValidator;
-#[allow(deprecated)]
-impl AddressValidator for DummyValidator {
-    fn validate(
-        &self,
-        keychain: KeychainKind,
-        hd_keypaths: &HdKeyPaths,
-        script: &Script,
-    ) -> Result<(), AddressValidatorError> {
-        let (_, path) = hd_keypaths
-            .values()
-            .find(|(fing, _)| fing == &Fingerprint::from_hex("bc123c3e").unwrap())
-            .ok_or(AddressValidatorError::InvalidScript)?;
-
-        println!(
-            "Validating `{:?}` {} address, script: {}",
-            keychain, path, script
-        );
-
-        Ok(())
-    }
-}
-
-fn main() -> Result<(), bdk::Error> {
-    let descriptor = "sh(and_v(v:pk(tpubDDpWvmUrPZrhSPmUzCMBHffvC3HyMAPnWDSAQNBTnj1iZeJa7BZQEttFiP4DS4GCcXQHezdXhn86Hj6LHX5EDstXPWrMaSneRWM8yUf6NFd/*),after(630000)))";
-    let mut wallet = Wallet::new(descriptor, None, Network::Regtest, MemoryDatabase::new())?;
-
-    #[allow(deprecated)]
-    wallet.add_address_validator(Arc::new(DummyValidator));
-
-    wallet.get_address(New)?;
-    wallet.get_address(New)?;
-    wallet.get_address(New)?;
-
-    Ok(())
-}

examples/compiler.rs

@@ -11,7 +11,6 @@
 
 extern crate bdk;
 extern crate bitcoin;
-extern crate clap;
 extern crate log;
 extern crate miniscript;
 extern crate serde_json;
@@ -21,8 +20,6 @@ use std::str::FromStr;
 
 use log::info;
 
-use clap::{App, Arg};
-
 use bitcoin::Network;
 use miniscript::policy::Concrete;
 use miniscript::Descriptor;
@@ -31,75 +28,49 @@ use bdk::database::memory::MemoryDatabase;
 use bdk::wallet::AddressIndex::New;
 use bdk::{KeychainKind, Wallet};
 
+/// Miniscript policy is a high level abstraction of spending conditions. Defined in the
+/// rust-miscript library here  https://docs.rs/miniscript/7.0.0/miniscript/policy/index.html
+/// rust-miniscript provides a `compile()` function that can be used to compile any miniscript policy
+/// into a descriptor. This descriptor then in turn can be used in bdk a fully functioning wallet
+/// can be derived from the policy.
+///
+/// This example demonstrates the interaction between a bdk wallet and miniscript policy.
+
 fn main() -> Result<(), Box<dyn Error>> {
     env_logger::init_from_env(
         env_logger::Env::default().filter_or(env_logger::DEFAULT_FILTER_ENV, "info"),
     );
 
-    let matches = App::new("Miniscript Compiler")
-        .arg(
-            Arg::with_name("POLICY")
-                .help("Sets the spending policy to compile")
-                .required(true)
-                .index(1),
-        )
-        .arg(
-            Arg::with_name("TYPE")
-                .help("Sets the script type used to embed the compiled policy")
-                .required(true)
-                .index(2)
-                .possible_values(&["sh", "wsh", "sh-wsh"]),
-        )
-        .arg(
-            Arg::with_name("parsed_policy")
-                .long("parsed_policy")
-                .short("p")
-                .help("Also return the parsed spending policy in JSON format"),
-        )
-        .arg(
-            Arg::with_name("network")
-                .short("n")
-                .long("network")
-                .help("Sets the network")
-                .takes_value(true)
-                .default_value("testnet")
-                .possible_values(&["testnet", "regtest", "bitcoin", "signet"]),
-        )
-        .get_matches();
-
-    let policy_str = matches.value_of("POLICY").unwrap();
-    info!("Compiling policy: {}", policy_str);
+    // We start with a generic miniscript policy string
+    let policy_str = "or(10@thresh(4,pk(029ffbe722b147f3035c87cb1c60b9a5947dd49c774cc31e94773478711a929ac0),pk(025f05815e3a1a8a83bfbb03ce016c9a2ee31066b98f567f6227df1d76ec4bd143),pk(025625f41e4a065efc06d5019cbbd56fe8c07595af1231e7cbc03fafb87ebb71ec),pk(02a27c8b850a00f67da3499b60562673dcf5fdfb82b7e17652a7ac54416812aefd),pk(03e618ec5f384d6e19ca9ebdb8e2119e5bef978285076828ce054e55c4daf473e2)),1@and(older(4209713),thresh(2,pk(03deae92101c790b12653231439f27b8897264125ecb2f46f48278603102573165),pk(033841045a531e1adf9910a6ec279589a90b3b8a904ee64ffd692bd08a8996c1aa),pk(02aebf2d10b040eb936a6f02f44ee82f8b34f5c1ccb20ff3949c2b28206b7c1068))))";
+    info!("Compiling policy: \n{}", policy_str);
 
+    // Parse the string as a [`Concrete`] type miniscript policy.
     let policy = Concrete::<String>::from_str(policy_str)?;
 
-    let descriptor = match matches.value_of("TYPE").unwrap() {
-        "sh" => Descriptor::new_sh(policy.compile()?)?,
-        "wsh" => Descriptor::new_wsh(policy.compile()?)?,
-        "sh-wsh" => Descriptor::new_sh_wsh(policy.compile()?)?,
-        _ => panic!("Invalid type"),
-    };
+    // Create a `wsh` type descriptor from the policy.
+    // `policy.compile()` returns the resulting miniscript from the policy.
+    let descriptor = Descriptor::new_wsh(policy.compile()?)?;
 
-    info!("... Descriptor: {}", descriptor);
+    info!("Compiled into following Descriptor: \n{}", descriptor);
 
     let database = MemoryDatabase::new();
 
-    let network = matches
-        .value_of("network")
-        .map(Network::from_str)
-        .transpose()
-        .unwrap()
-        .unwrap_or(Network::Testnet);
-    let wallet = Wallet::new(&format!("{}", descriptor), None, network, database)?;
+    // Create a new wallet from this descriptor
+    let wallet = Wallet::new(&format!("{}", descriptor), None, Network::Regtest, database)?;
 
-    info!("... First address: {}", wallet.get_address(New)?);
+    info!(
+        "First derived address from the descriptor: \n{}",
+        wallet.get_address(New)?
+    );
 
-    if matches.is_present("parsed_policy") {
-        let spending_policy = wallet.policies(KeychainKind::External)?;
-        info!(
-            "... Spending policy:\n{}",
-            serde_json::to_string_pretty(&spending_policy)?
-        );
-    }
+    // BDK also has it's own `Policy` structure to represent the spending condition in a more
+    // human readable json format.
+    let spending_policy = wallet.policies(KeychainKind::External)?;
+    info!(
+        "The BDK spending policy: \n{}",
+        serde_json::to_string_pretty(&spending_policy)?
+    );
 
     Ok(())
 }

examples/electrum_backend.rs

@@ -0,0 +1,87 @@
+use std::str::FromStr;
+
+use bdk::bitcoin::util::bip32::ExtendedPrivKey;
+use bdk::bitcoin::Network;
+use bdk::blockchain::{Blockchain, ElectrumBlockchain};
+use bdk::database::MemoryDatabase;
+use bdk::template::Bip84;
+use bdk::wallet::export::FullyNodedExport;
+use bdk::{KeychainKind, SyncOptions, Wallet};
+
+use bdk::electrum_client::Client;
+use bdk::wallet::AddressIndex;
+use bitcoin::util::bip32;
+
+pub mod utils;
+
+use crate::utils::tx::build_signed_tx;
+
+/// This will create a wallet from an xpriv and get the balance by connecting to an Electrum server.
+/// If enough amount is available, this will send a transaction to an address.
+/// Otherwise, this will display a wallet address to receive funds.
+///
+/// This can be run with `cargo run --example electrum_backend` in the root folder.
+fn main() {
+    let network = Network::Testnet;
+
+    let xpriv = "tprv8ZgxMBicQKsPcx5nBGsR63Pe8KnRUqmbJNENAfGftF3yuXoMMoVJJcYeUw5eVkm9WBPjWYt6HMWYJNesB5HaNVBaFc1M6dRjWSYnmewUMYy";
+
+    let electrum_url = "ssl://electrum.blockstream.info:60002";
+
+    run(&network, electrum_url, xpriv);
+}
+
+fn create_wallet(network: &Network, xpriv: &ExtendedPrivKey) -> Wallet<MemoryDatabase> {
+    Wallet::new(
+        Bip84(*xpriv, KeychainKind::External),
+        Some(Bip84(*xpriv, KeychainKind::Internal)),
+        *network,
+        MemoryDatabase::default(),
+    )
+    .unwrap()
+}
+
+fn run(network: &Network, electrum_url: &str, xpriv: &str) {
+    let xpriv = bip32::ExtendedPrivKey::from_str(xpriv).unwrap();
+
+    // Apparently it works only with Electrs (not EletrumX)
+    let blockchain = ElectrumBlockchain::from(Client::new(electrum_url).unwrap());
+
+    let wallet = create_wallet(network, &xpriv);
+
+    wallet.sync(&blockchain, SyncOptions::default()).unwrap();
+
+    let address = wallet.get_address(AddressIndex::New).unwrap().address;
+
+    println!("address: {}", address);
+
+    let balance = wallet.get_balance().unwrap();
+
+    println!("Available coins in BDK wallet : {} sats", balance);
+
+    if balance.confirmed > 6500 {
+        // the wallet sends the amount to itself.
+        let recipient_address = wallet
+            .get_address(AddressIndex::New)
+            .unwrap()
+            .address
+            .to_string();
+
+        let amount = 5359;
+
+        let tx = build_signed_tx(&wallet, &recipient_address, amount);
+
+        blockchain.broadcast(&tx).unwrap();
+
+        println!("tx id: {}", tx.txid());
+    } else {
+        println!("Insufficient Funds. Fund the wallet with the address above");
+    }
+
+    let export = FullyNodedExport::export_wallet(&wallet, "exported wallet", true)
+        .map_err(ToString::to_string)
+        .map_err(bdk::Error::Generic)
+        .unwrap();
+
+    println!("------\nWallet Backup: {}", export.to_string());
+}

examples/esplora_backend_asynchronous.rs

@@ -0,0 +1,93 @@
+use std::str::FromStr;
+
+use bdk::blockchain::Blockchain;
+use bdk::{
+    blockchain::esplora::EsploraBlockchain,
+    database::MemoryDatabase,
+    template::Bip84,
+    wallet::{export::FullyNodedExport, AddressIndex},
+    KeychainKind, SyncOptions, Wallet,
+};
+use bitcoin::{
+    util::bip32::{self, ExtendedPrivKey},
+    Network,
+};
+
+pub mod utils;
+
+use crate::utils::tx::build_signed_tx;
+
+/// This will create a wallet from an xpriv and get the balance by connecting to an Esplora server,
+/// using non blocking asynchronous calls with `reqwest`.
+/// If enough amount is available, this will send a transaction to an address.
+/// Otherwise, this will display a wallet address to receive funds.
+///
+/// This can be run with `cargo run --no-default-features --features="use-esplora-reqwest, reqwest-default-tls, async-interface" --example esplora_backend_asynchronous`
+/// in the root folder.
+#[tokio::main(flavor = "current_thread")]
+async fn main() {
+    let network = Network::Signet;
+
+    let xpriv = "tprv8ZgxMBicQKsPcx5nBGsR63Pe8KnRUqmbJNENAfGftF3yuXoMMoVJJcYeUw5eVkm9WBPjWYt6HMWYJNesB5HaNVBaFc1M6dRjWSYnmewUMYy";
+
+    let esplora_url = "https://explorer.bc-2.jp/api";
+
+    run(&network, esplora_url, xpriv).await;
+}
+
+fn create_wallet(network: &Network, xpriv: &ExtendedPrivKey) -> Wallet<MemoryDatabase> {
+    Wallet::new(
+        Bip84(*xpriv, KeychainKind::External),
+        Some(Bip84(*xpriv, KeychainKind::Internal)),
+        *network,
+        MemoryDatabase::default(),
+    )
+    .unwrap()
+}
+
+async fn run(network: &Network, esplora_url: &str, xpriv: &str) {
+    let xpriv = bip32::ExtendedPrivKey::from_str(xpriv).unwrap();
+
+    let blockchain = EsploraBlockchain::new(esplora_url, 20);
+
+    let wallet = create_wallet(network, &xpriv);
+
+    wallet
+        .sync(&blockchain, SyncOptions::default())
+        .await
+        .unwrap();
+
+    let address = wallet.get_address(AddressIndex::New).unwrap().address;
+
+    println!("address: {}", address);
+
+    let balance = wallet.get_balance().unwrap();
+
+    println!("Available coins in BDK wallet : {} sats", balance);
+
+    if balance.confirmed > 10500 {
+        // the wallet sends the amount to itself.
+        let recipient_address = wallet
+            .get_address(AddressIndex::New)
+            .unwrap()
+            .address
+            .to_string();
+
+        let amount = 9359;
+
+        let tx = build_signed_tx(&wallet, &recipient_address, amount);
+
+        let _ = blockchain.broadcast(&tx);
+
+        println!("tx id: {}", tx.txid());
+    } else {
+        println!("Insufficient Funds. Fund the wallet with the address above");
+    }
+
+    let export = FullyNodedExport::export_wallet(&wallet, "exported wallet", true)
+        .map_err(ToString::to_string)
+        .map_err(bdk::Error::Generic)
+        .unwrap();
+
+    println!("------\nWallet Backup: {}", export.to_string());
+}

examples/esplora_backend_synchronous.rs

@@ -0,0 +1,89 @@
+use std::str::FromStr;
+
+use bdk::blockchain::Blockchain;
+use bdk::{
+    blockchain::esplora::EsploraBlockchain,
+    database::MemoryDatabase,
+    template::Bip84,
+    wallet::{export::FullyNodedExport, AddressIndex},
+    KeychainKind, SyncOptions, Wallet,
+};
+use bitcoin::{
+    util::bip32::{self, ExtendedPrivKey},
+    Network,
+};
+
+pub mod utils;
+
+use crate::utils::tx::build_signed_tx;
+
+/// This will create a wallet from an xpriv and get the balance by connecting to an Esplora server,
+/// using blocking calls with `ureq`.
+/// If enough amount is available, this will send a transaction to an address.
+/// Otherwise, this will display a wallet address to receive funds.
+///
+/// This can be run with `cargo run --features=use-esplora-ureq --example esplora_backend_synchronous`
+/// in the root folder.
+fn main() {
+    let network = Network::Signet;
+
+    let xpriv = "tprv8ZgxMBicQKsPcx5nBGsR63Pe8KnRUqmbJNENAfGftF3yuXoMMoVJJcYeUw5eVkm9WBPjWYt6HMWYJNesB5HaNVBaFc1M6dRjWSYnmewUMYy";
+
+    let esplora_url = "https://explorer.bc-2.jp/api";
+
+    run(&network, esplora_url, xpriv);
+}
+
+fn create_wallet(network: &Network, xpriv: &ExtendedPrivKey) -> Wallet<MemoryDatabase> {
+    Wallet::new(
+        Bip84(*xpriv, KeychainKind::External),
+        Some(Bip84(*xpriv, KeychainKind::Internal)),
+        *network,
+        MemoryDatabase::default(),
+    )
+    .unwrap()
+}
+
+fn run(network: &Network, esplora_url: &str, xpriv: &str) {
+    let xpriv = bip32::ExtendedPrivKey::from_str(xpriv).unwrap();
+
+    let blockchain = EsploraBlockchain::new(esplora_url, 20);
+
+    let wallet = create_wallet(network, &xpriv);
+
+    wallet.sync(&blockchain, SyncOptions::default()).unwrap();
+
+    let address = wallet.get_address(AddressIndex::New).unwrap().address;
+
+    println!("address: {}", address);
+
+    let balance = wallet.get_balance().unwrap();
+
+    println!("Available coins in BDK wallet : {} sats", balance);
+
+    if balance.confirmed > 10500 {
+        // the wallet sends the amount to itself.
+        let recipient_address = wallet
+            .get_address(AddressIndex::New)
+            .unwrap()
+            .address
+            .to_string();
+
+        let amount = 9359;
+
+        let tx = build_signed_tx(&wallet, &recipient_address, amount);
+
+        blockchain.broadcast(&tx).unwrap();
+
+        println!("tx id: {}", tx.txid());
+    } else {
+        println!("Insufficient Funds. Fund the wallet with the address above");
+    }
+
+    let export = FullyNodedExport::export_wallet(&wallet, "exported wallet", true)
+        .map_err(ToString::to_string)
+        .map_err(bdk::Error::Generic)
+        .unwrap();
+
+    println!("------\nWallet Backup: {}", export.to_string());
+}

examples/hardware_signer.rs

@@ -0,0 +1,103 @@
+use bdk::bitcoin::{Address, Network};
+use bdk::blockchain::{Blockchain, ElectrumBlockchain};
+use bdk::database::MemoryDatabase;
+use bdk::hwi::{types::HWIChain, HWIClient};
+use bdk::signer::SignerOrdering;
+use bdk::wallet::{hardwaresigner::HWISigner, AddressIndex};
+use bdk::{FeeRate, KeychainKind, SignOptions, SyncOptions, Wallet};
+use electrum_client::Client;
+use std::str::FromStr;
+use std::sync::Arc;
+
+// This example shows how to sync a wallet, create a transaction, sign it
+// and broadcast it using an external hardware wallet.
+// The hardware wallet must be connected to the computer and unlocked before
+// running the example. Also, the `hwi` python package should be installed
+// and available in the environment.
+//
+// To avoid loss of funds, consider using an hardware wallet simulator:
+// * Coldcard: https://github.com/Coldcard/firmware
+// * Ledger: https://github.com/LedgerHQ/speculos
+// * Trezor: https://docs.trezor.io/trezor-firmware/core/emulator/index.html
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    println!("Hold tight, I'm connecting to your hardware wallet...");
+
+    // Listing all the available hardware wallet devices...
+    let devices = HWIClient::enumerate()?;
+    let first_device = devices
+        .first()
+        .expect("No devices found. Either plug in a hardware wallet, or start a simulator.");
+    // ...and creating a client out of the first one
+    let client = HWIClient::get_client(first_device, true, HWIChain::Test)?;
+    println!("Look what I found, a {}!", first_device.model);
+
+    // Getting the HW's public descriptors
+    let descriptors = client.get_descriptors(None)?;
+    println!(
+        "The hardware wallet's descriptor is: {}",
+        descriptors.receive[0]
+    );
+
+    // Creating a custom signer from the device
+    let custom_signer = HWISigner::from_device(first_device, HWIChain::Test)?;
+    let mut wallet = Wallet::new(
+        &descriptors.receive[0],
+        Some(&descriptors.internal[0]),
+        Network::Testnet,
+        MemoryDatabase::default(),
+    )?;
+
+    // Adding the hardware signer to the BDK wallet
+    wallet.add_signer(
+        KeychainKind::External,
+        SignerOrdering(200),
+        Arc::new(custom_signer),
+    );
+
+    // create client for Blockstream's testnet electrum server
+    let blockchain =
+        ElectrumBlockchain::from(Client::new("ssl://electrum.blockstream.info:60002")?);
+
+    println!("Syncing the wallet...");
+    wallet.sync(&blockchain, SyncOptions::default())?;
+
+    // get deposit address
+    let deposit_address = wallet.get_address(AddressIndex::New)?;
+
+    let balance = wallet.get_balance()?;
+    println!("Wallet balances in SATs: {}", balance);
+
+    if balance.get_total() < 10000 {
+        println!(
+            "Send some sats from the u01.net testnet faucet to address '{addr}'.\nFaucet URL: https://bitcoinfaucet.uo1.net/?to={addr}",
+            addr = deposit_address.address
+        );
+        return Ok(());
+    }
+
+    let return_address = Address::from_str("tb1ql7w62elx9ucw4pj5lgw4l028hmuw80sndtntxt")?;
+    let (mut psbt, _details) = {
+        let mut builder = wallet.build_tx();
+        builder
+            .drain_wallet()
+            .drain_to(return_address.script_pubkey())
+            .enable_rbf()
+            .fee_rate(FeeRate::from_sat_per_vb(5.0));
+        builder.finish()?
+    };
+
+    // `sign` will call the hardware wallet asking for a signature
+    assert!(
+        wallet.sign(&mut psbt, SignOptions::default())?,
+        "The hardware wallet couldn't finalize the transaction :("
+    );
+
+    println!("Let's broadcast your tx...");
+    let raw_transaction = psbt.extract_tx();
+    let txid = raw_transaction.txid();
+
+    blockchain.broadcast(&raw_transaction)?;
+    println!("Transaction broadcasted! TXID: {txid}.\nExplorer URL: https://mempool.space/testnet/tx/{txid}", txid = txid);
+
+    Ok(())
+}

examples/mnemonic_to_descriptors.rs

@@ -0,0 +1,60 @@
+// Copyright (c) 2020-2021 Bitcoin Dev Kit Developers
+//
+// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
+// or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
+// You may not use this file except in accordance with one or both of these
+// licenses.
+
+use bdk::bitcoin::secp256k1::Secp256k1;
+use bdk::bitcoin::util::bip32::DerivationPath;
+use bdk::bitcoin::Network;
+use bdk::descriptor;
+use bdk::descriptor::IntoWalletDescriptor;
+use bdk::keys::bip39::{Language, Mnemonic, WordCount};
+use bdk::keys::{GeneratableKey, GeneratedKey};
+use bdk::miniscript::Tap;
+use bdk::Error as BDK_Error;
+use std::error::Error;
+use std::str::FromStr;
+
+/// This example demonstrates how to generate a mnemonic phrase
+/// using BDK and use that to generate a descriptor string.
+fn main() -> Result<(), Box<dyn Error>> {
+    let secp = Secp256k1::new();
+
+    // In this example we are generating a 12 words mnemonic phrase
+    // but it is also possible generate 15, 18, 21 and 24 words
+    // using their respective `WordCount` variant.
+    let mnemonic: GeneratedKey<_, Tap> =
+        Mnemonic::generate((WordCount::Words12, Language::English))
+            .map_err(|_| BDK_Error::Generic("Mnemonic generation error".to_string()))?;
+
+    println!("Mnemonic phrase: {}", *mnemonic);
+    let mnemonic_with_passphrase = (mnemonic, None);
+
+    // define external and internal derivation key path
+    let external_path = DerivationPath::from_str("m/86h/0h/0h/0").unwrap();
+    let internal_path = DerivationPath::from_str("m/86h/0h/0h/1").unwrap();
+
+    // generate external and internal descriptor from mnemonic
+    let (external_descriptor, ext_keymap) =
+        descriptor!(tr((mnemonic_with_passphrase.clone(), external_path)))?
+            .into_wallet_descriptor(&secp, Network::Testnet)?;
+    let (internal_descriptor, int_keymap) =
+        descriptor!(tr((mnemonic_with_passphrase, internal_path)))?
+            .into_wallet_descriptor(&secp, Network::Testnet)?;
+
+    println!("tpub external descriptor: {}", external_descriptor);
+    println!("tpub internal descriptor: {}", internal_descriptor);
+    println!(
+        "tprv external descriptor: {}",
+        external_descriptor.to_string_with_secret(&ext_keymap)
+    );
+    println!(
+        "tprv internal descriptor: {}",
+        internal_descriptor.to_string_with_secret(&int_keymap)
+    );
+
+    Ok(())
+}

examples/policy.rs

@@ -0,0 +1,66 @@
+// 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.
+
+extern crate bdk;
+extern crate env_logger;
+extern crate log;
+use std::error::Error;
+
+use bdk::bitcoin::Network;
+use bdk::descriptor::{policy::BuildSatisfaction, ExtractPolicy, IntoWalletDescriptor};
+use bdk::wallet::signer::SignersContainer;
+
+/// This example describes the use of the BDK's [`bdk::descriptor::policy`] module.
+///
+/// Policy is higher abstraction representation of the wallet descriptor spending condition.
+/// This is useful to express complex miniscript spending conditions into more human readable form.
+/// The resulting `Policy` structure  can be used to derive spending conditions the wallet is capable
+/// to spend from.
+///
+/// This example demos a Policy output for a 2of2 multisig between between 2 parties, where the wallet holds
+/// one of the Extend Private key.
+
+fn main() -> Result<(), Box<dyn Error>> {
+    env_logger::init_from_env(
+        env_logger::Env::default().filter_or(env_logger::DEFAULT_FILTER_ENV, "info"),
+    );
+
+    let secp = bitcoin::secp256k1::Secp256k1::new();
+
+    // The descriptor used in the example
+    // The form is "wsh(multi(2, <privkey>, <pubkey>))"
+    let desc = "wsh(multi(2,tprv8ZgxMBicQKsPdpkqS7Eair4YxjcuuvDPNYmKX3sCniCf16tHEVrjjiSXEkFRnUH77yXc6ZcwHHcLNfjdi5qUvw3VDfgYiH5mNsj5izuiu2N/1/*,tpubD6NzVbkrYhZ4XHndKkuB8FifXm8r5FQHwrN6oZuWCz13qb93rtgKvD4PQsqC4HP4yhV3tA2fqr2RbY5mNXfM7RxXUoeABoDtsFUq2zJq6YK/1/*))";
+
+    // Use the descriptor string to derive the full descriptor and a keymap.
+    // The wallet descriptor can be used to create a new bdk::wallet.
+    // While the `keymap` can be used to create a `SignerContainer`.
+    //
+    // The `SignerContainer` can sign for `PSBT`s.
+    // a bdk::wallet internally uses these to handle transaction signing.
+    // But they can be used as independent tools also.
+    let (wallet_desc, keymap) = desc.into_wallet_descriptor(&secp, Network::Testnet)?;
+
+    log::info!("Example Descriptor for policy analysis : {}", wallet_desc);
+
+    // Create the signer with the keymap and descriptor.
+    let signers_container = SignersContainer::build(keymap, &wallet_desc, &secp);
+
+    // Extract the Policy from the given descriptor and signer.
+    // Note that Policy is a wallet specific structure. It depends on the the descriptor, and
+    // what the concerned wallet with a given signer can sign for.
+    let policy = wallet_desc
+        .extract_policy(&signers_container, BuildSatisfaction::None, &secp)?
+        .expect("We expect a policy");
+
+    log::info!("Derived Policy for the descriptor {:#?}", policy);
+
+    Ok(())
+}

examples/psbt_signer.rs

@@ -0,0 +1,120 @@
+// Copyright (c) 2020-2022 Bitcoin Dev Kit Developers
+//
+// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
+// or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
+// You may not use this file except in accordance with one or both of these
+// licenses.
+
+use bdk::blockchain::{Blockchain, ElectrumBlockchain};
+use bdk::database::MemoryDatabase;
+use bdk::wallet::AddressIndex;
+use bdk::{descriptor, SyncOptions};
+use bdk::{FeeRate, SignOptions, Wallet};
+use bitcoin::secp256k1::Secp256k1;
+use bitcoin::{Address, Network};
+use electrum_client::Client;
+use miniscript::descriptor::DescriptorSecretKey;
+use std::error::Error;
+use std::str::FromStr;
+
+/// This example shows how to sign and broadcast the transaction for a PSBT (Partially Signed
+/// Bitcoin Transaction) for a single key, witness public key hash (WPKH) based descriptor wallet.
+/// The electrum protocol is used to sync blockchain data from the testnet bitcoin network and
+/// wallet data is stored in an ephemeral in-memory database. The process steps are:
+/// 1. Create a "signing" wallet and a "watch-only" wallet based on the same private keys.
+/// 2. Deposit testnet funds into the watch only wallet.
+/// 3. Sync the watch only wallet and create a spending transaction to return all funds to the testnet faucet.
+/// 4. Sync the signing wallet and sign and finalize the PSBT created by the watch only wallet.
+/// 5. Broadcast the transactions from the finalized PSBT.
+fn main() -> Result<(), Box<dyn Error>> {
+    // test key created with `bdk-cli key generate` and `bdk-cli key derive` commands
+    let external_secret_xkey = DescriptorSecretKey::from_str("[e9824965/84'/1'/0']tprv8fvem7qWxY3SGCQczQpRpqTKg455wf1zgixn6MZ4ze8gRfHjov5gXBQTadNfDgqs9ERbZZ3Bi1PNYrCCusFLucT39K525MWLpeURjHwUsfX/0/*").unwrap();
+    let internal_secret_xkey = DescriptorSecretKey::from_str("[e9824965/84'/1'/0']tprv8fvem7qWxY3SGCQczQpRpqTKg455wf1zgixn6MZ4ze8gRfHjov5gXBQTadNfDgqs9ERbZZ3Bi1PNYrCCusFLucT39K525MWLpeURjHwUsfX/1/*").unwrap();
+
+    let secp = Secp256k1::new();
+    let external_public_xkey = external_secret_xkey.to_public(&secp).unwrap();
+    let internal_public_xkey = internal_secret_xkey.to_public(&secp).unwrap();
+
+    let signing_external_descriptor = descriptor!(wpkh(external_secret_xkey)).unwrap();
+    let signing_internal_descriptor = descriptor!(wpkh(internal_secret_xkey)).unwrap();
+
+    let watch_only_external_descriptor = descriptor!(wpkh(external_public_xkey)).unwrap();
+    let watch_only_internal_descriptor = descriptor!(wpkh(internal_public_xkey)).unwrap();
+
+    // create client for Blockstream's testnet electrum server
+    let blockchain =
+        ElectrumBlockchain::from(Client::new("ssl://electrum.blockstream.info:60002")?);
+
+    // create watch only wallet
+    let watch_only_wallet: Wallet<MemoryDatabase> = Wallet::new(
+        watch_only_external_descriptor,
+        Some(watch_only_internal_descriptor),
+        Network::Testnet,
+        MemoryDatabase::default(),
+    )?;
+
+    // create signing wallet
+    let signing_wallet: Wallet<MemoryDatabase> = Wallet::new(
+        signing_external_descriptor,
+        Some(signing_internal_descriptor),
+        Network::Testnet,
+        MemoryDatabase::default(),
+    )?;
+
+    println!("Syncing watch only wallet.");
+    watch_only_wallet.sync(&blockchain, SyncOptions::default())?;
+
+    // get deposit address
+    let deposit_address = watch_only_wallet.get_address(AddressIndex::New)?;
+
+    let balance = watch_only_wallet.get_balance()?;
+    println!("Watch only wallet balances in SATs: {}", balance);
+
+    if balance.get_total() < 10000 {
+        println!(
+            "Send at least 10000 SATs (0.0001 BTC) from the u01.net testnet faucet to address '{addr}'.\nFaucet URL: https://bitcoinfaucet.uo1.net/?to={addr}",
+            addr = deposit_address.address
+        );
+    } else if balance.get_spendable() < 10000 {
+        println!(
+            "Wait for at least 10000 SATs of your wallet transactions to be confirmed...\nBe patient, this could take 10 mins or longer depending on how testnet is behaving."
+        );
+        for tx_details in watch_only_wallet
+            .list_transactions(false)?
+            .iter()
+            .filter(|txd| txd.received > 0 && txd.confirmation_time.is_none())
+        {
+            println!(
+                "See unconfirmed tx for {} SATs: https://mempool.space/testnet/tx/{}",
+                tx_details.received, tx_details.txid
+            );
+        }
+    } else {
+        println!("Creating a PSBT sending 9800 SATs plus fee to the u01.net testnet faucet return address 'tb1ql7w62elx9ucw4pj5lgw4l028hmuw80sndtntxt'.");
+        let return_address = Address::from_str("tb1ql7w62elx9ucw4pj5lgw4l028hmuw80sndtntxt")?;
+        let mut builder = watch_only_wallet.build_tx();
+        builder
+            .add_recipient(return_address.script_pubkey(), 9_800)
+            .enable_rbf()
+            .fee_rate(FeeRate::from_sat_per_vb(1.0));
+
+        let (mut psbt, details) = builder.finish()?;
+        println!("Transaction details: {:#?}", details);
+        println!("Unsigned PSBT: {}", psbt);
+
+        // Sign and finalize the PSBT with the signing wallet
+        let finalized = signing_wallet.sign(&mut psbt, SignOptions::default())?;
+        assert!(finalized, "The PSBT was not finalized!");
+        println!("The PSBT has been signed and finalized.");
+
+        // Broadcast the transaction
+        let raw_transaction = psbt.extract_tx();
+        let txid = raw_transaction.txid();
+
+        blockchain.broadcast(&raw_transaction)?;
+        println!("Transaction broadcast! TXID: {txid}.\nExplorer URL: https://mempool.space/testnet/tx/{txid}", txid = txid);
+    }
+
+    Ok(())
+}

examples/utils/mod.rs

@@ -0,0 +1,30 @@
+pub(crate) mod tx {
+
+    use std::str::FromStr;
+
+    use bdk::{database::BatchDatabase, SignOptions, Wallet};
+    use bitcoin::{Address, Transaction};
+
+    pub fn build_signed_tx<D: BatchDatabase>(
+        wallet: &Wallet<D>,
+        recipient_address: &str,
+        amount: u64,
+    ) -> Transaction {
+        // Create a transaction builder
+        let mut tx_builder = wallet.build_tx();
+
+        let to_address = Address::from_str(recipient_address).unwrap();
+
+        // Set recipient of the transaction
+        tx_builder.set_recipients(vec![(to_address.script_pubkey(), amount)]);
+
+        // Finalise the transaction and extract PSBT
+        let (mut psbt, _) = tx_builder.finish().unwrap();
+
+        // Sign the above psbt with signing option
+        wallet.sign(&mut psbt, SignOptions::default()).unwrap();
+
+        // Extract the final transaction
+        psbt.extract_tx()
+    }
+}

src/blockchain/any.rs

@@ -194,7 +194,7 @@ impl_from!(boxed rpc::RpcBlockchain, AnyBlockchain, Rpc, #[cfg(feature = "rpc")]
 /// );
 /// # }
 /// ```
-#[derive(Debug, serde::Serialize, serde::Deserialize, Clone, PartialEq)]
+#[derive(Debug, serde::Serialize, serde::Deserialize, Clone, PartialEq, Eq)]
 #[serde(tag = "type", rename_all = "snake_case")]
 pub enum AnyBlockchainConfig {
     #[cfg(feature = "electrum")]

src/blockchain/compact_filters/mod.rs

@@ -479,7 +479,7 @@ impl WalletSync for CompactFiltersBlockchain {
 }
 
 /// Data to connect to a Bitcoin P2P peer
-#[derive(Debug, serde::Deserialize, serde::Serialize, Clone, PartialEq)]
+#[derive(Debug, serde::Deserialize, serde::Serialize, Clone, PartialEq, Eq)]
 pub struct BitcoinPeerConfig {
     /// Peer address such as 127.0.0.1:18333
     pub address: String,
@@ -490,7 +490,7 @@ pub struct BitcoinPeerConfig {
 }
 
 /// Configuration for a [`CompactFiltersBlockchain`]
-#[derive(Debug, serde::Deserialize, serde::Serialize, Clone, PartialEq)]
+#[derive(Debug, serde::Deserialize, serde::Serialize, Clone, PartialEq, Eq)]
 pub struct CompactFiltersBlockchainConfig {
     /// List of peers to try to connect to for asking headers and filters
     pub peers: Vec<BitcoinPeerConfig>,

src/blockchain/compact_filters/peer.rs

@@ -75,7 +75,10 @@ impl Mempool {
     /// Look-up a transaction in the mempool given an [`Inventory`] request
     pub fn get_tx(&self, inventory: &Inventory) -> Option<Transaction> {
         let identifer = match inventory {
-            Inventory::Error | Inventory::Block(_) | Inventory::WitnessBlock(_) => return None,
+            Inventory::Error
+            | Inventory::Block(_)
+            | Inventory::WitnessBlock(_)
+            | Inventory::CompactBlock(_) => return None,
             Inventory::Transaction(txid) => TxIdentifier::Txid(*txid),
             Inventory::WitnessTransaction(txid) => TxIdentifier::Txid(*txid),
             Inventory::WTx(wtxid) => TxIdentifier::Wtxid(*wtxid),

src/blockchain/compact_filters/store.rs

@@ -13,7 +13,6 @@ use std::convert::TryInto;
 use std::fmt;
 use std::io::{Read, Write};
 use std::marker::PhantomData;
-use std::ops::Deref;
 use std::sync::Arc;
 use std::sync::RwLock;
 
@@ -22,9 +21,9 @@ use rand::{thread_rng, Rng};
 
 use rocksdb::{Direction, IteratorMode, ReadOptions, WriteBatch, DB};
 
+use bitcoin::blockdata::constants::genesis_block;
 use bitcoin::consensus::{deserialize, encode::VarInt, serialize, Decodable, Encodable};
 use bitcoin::hash_types::{FilterHash, FilterHeader};
-use bitcoin::hashes::hex::FromHex;
 use bitcoin::hashes::Hash;
 use bitcoin::util::bip158::BlockFilter;
 use bitcoin::util::uint::Uint256;
@@ -33,17 +32,8 @@ use bitcoin::BlockHash;
 use bitcoin::BlockHeader;
 use bitcoin::Network;
 
-use lazy_static::lazy_static;
-
 use super::CompactFiltersError;
 
-lazy_static! {
-    static ref MAINNET_GENESIS: Block = deserialize(&Vec::<u8>::from_hex("0100000000000000000000000000000000000000000000000000000000000000000000003BA3EDFD7A7B12B27AC72C3E67768F617FC81BC3888A51323A9FB8AA4B1E5E4A29AB5F49FFFF001D1DAC2B7C0101000000010000000000000000000000000000000000000000000000000000000000000000FFFFFFFF4D04FFFF001D0104455468652054696D65732030332F4A616E2F32303039204368616E63656C6C6F72206F6E206272696E6B206F66207365636F6E64206261696C6F757420666F722062616E6B73FFFFFFFF0100F2052A01000000434104678AFDB0FE5548271967F1A67130B7105CD6A828E03909A67962E0EA1F61DEB649F6BC3F4CEF38C4F35504E51EC112DE5C384DF7BA0B8D578A4C702B6BF11D5FAC00000000").unwrap()).unwrap();
-    static ref TESTNET_GENESIS: Block = deserialize(&Vec::<u8>::from_hex("0100000000000000000000000000000000000000000000000000000000000000000000003BA3EDFD7A7B12B27AC72C3E67768F617FC81BC3888A51323A9FB8AA4B1E5E4ADAE5494DFFFF001D1AA4AE180101000000010000000000000000000000000000000000000000000000000000000000000000FFFFFFFF4D04FFFF001D0104455468652054696D65732030332F4A616E2F32303039204368616E63656C6C6F72206F6E206272696E6B206F66207365636F6E64206261696C6F757420666F722062616E6B73FFFFFFFF0100F2052A01000000434104678AFDB0FE5548271967F1A67130B7105CD6A828E03909A67962E0EA1F61DEB649F6BC3F4CEF38C4F35504E51EC112DE5C384DF7BA0B8D578A4C702B6BF11D5FAC00000000").unwrap()).unwrap();
-    static ref REGTEST_GENESIS: Block = deserialize(&Vec::<u8>::from_hex("0100000000000000000000000000000000000000000000000000000000000000000000003BA3EDFD7A7B12B27AC72C3E67768F617FC81BC3888A51323A9FB8AA4B1E5E4ADAE5494DFFFF7F20020000000101000000010000000000000000000000000000000000000000000000000000000000000000FFFFFFFF4D04FFFF001D0104455468652054696D65732030332F4A616E2F32303039204368616E63656C6C6F72206F6E206272696E6B206F66207365636F6E64206261696C6F757420666F722062616E6B73FFFFFFFF0100F2052A01000000434104678AFDB0FE5548271967F1A67130B7105CD6A828E03909A67962E0EA1F61DEB649F6BC3F4CEF38C4F35504E51EC112DE5C384DF7BA0B8D578A4C702B6BF11D5FAC00000000").unwrap()).unwrap();
-    static ref SIGNET_GENESIS: Block = deserialize(&Vec::<u8>::from_hex("0100000000000000000000000000000000000000000000000000000000000000000000003BA3EDFD7A7B12B27AC72C3E67768F617FC81BC3888A51323A9FB8AA4B1E5E4A008F4D5FAE77031E8AD222030101000000010000000000000000000000000000000000000000000000000000000000000000FFFFFFFF4D04FFFF001D0104455468652054696D65732030332F4A616E2F32303039204368616E63656C6C6F72206F6E206272696E6B206F66207365636F6E64206261696C6F757420666F722062616E6B73FFFFFFFF0100F2052A01000000434104678AFDB0FE5548271967F1A67130B7105CD6A828E03909A67962E0EA1F61DEB649F6BC3F4CEF38C4F35504E51EC112DE5C384DF7BA0B8D578A4C702B6BF11D5FAC00000000").unwrap()).unwrap();
-}
-
 pub trait StoreType: Default + fmt::Debug {}
 
 #[derive(Default, Debug)]
@@ -113,42 +103,42 @@ where
 }
 
 impl Encodable for BundleStatus {
-    fn consensus_encode<W: Write>(&self, mut e: W) -> Result<usize, std::io::Error> {
+    fn consensus_encode<W: Write + ?Sized>(&self, e: &mut W) -> Result<usize, std::io::Error> {
         let mut written = 0;
 
         match self {
             BundleStatus::Init => {
-                written += 0x00u8.consensus_encode(&mut e)?;
+                written += 0x00u8.consensus_encode(e)?;
             }
             BundleStatus::CfHeaders { cf_headers } => {
-                written += 0x01u8.consensus_encode(&mut e)?;
-                written += VarInt(cf_headers.len() as u64).consensus_encode(&mut e)?;
+                written += 0x01u8.consensus_encode(e)?;
+                written += VarInt(cf_headers.len() as u64).consensus_encode(e)?;
                 for header in cf_headers {
-                    written += header.consensus_encode(&mut e)?;
+                    written += header.consensus_encode(e)?;
                 }
             }
             BundleStatus::CFilters { cf_filters } => {
-                written += 0x02u8.consensus_encode(&mut e)?;
-                written += VarInt(cf_filters.len() as u64).consensus_encode(&mut e)?;
+                written += 0x02u8.consensus_encode(e)?;
+                written += VarInt(cf_filters.len() as u64).consensus_encode(e)?;
                 for filter in cf_filters {
-                    written += filter.consensus_encode(&mut e)?;
+                    written += filter.consensus_encode(e)?;
                 }
             }
             BundleStatus::Processed { cf_filters } => {
-                written += 0x03u8.consensus_encode(&mut e)?;
-                written += VarInt(cf_filters.len() as u64).consensus_encode(&mut e)?;
+                written += 0x03u8.consensus_encode(e)?;
+                written += VarInt(cf_filters.len() as u64).consensus_encode(e)?;
                 for filter in cf_filters {
-                    written += filter.consensus_encode(&mut e)?;
+                    written += filter.consensus_encode(e)?;
                 }
             }
             BundleStatus::Pruned => {
-                written += 0x04u8.consensus_encode(&mut e)?;
+                written += 0x04u8.consensus_encode(e)?;
             }
             BundleStatus::Tip { cf_filters } => {
-                written += 0x05u8.consensus_encode(&mut e)?;
-                written += VarInt(cf_filters.len() as u64).consensus_encode(&mut e)?;
+                written += 0x05u8.consensus_encode(e)?;
+                written += VarInt(cf_filters.len() as u64).consensus_encode(e)?;
                 for filter in cf_filters {
-                    written += filter.consensus_encode(&mut e)?;
+                    written += filter.consensus_encode(e)?;
                 }
             }
         }
@@ -158,51 +148,53 @@ impl Encodable for BundleStatus {
 }
 
 impl Decodable for BundleStatus {
-    fn consensus_decode<D: Read>(mut d: D) -> Result<Self, bitcoin::consensus::encode::Error> {
-        let byte_type = u8::consensus_decode(&mut d)?;
+    fn consensus_decode<D: Read + ?Sized>(
+        d: &mut D,
+    ) -> Result<Self, bitcoin::consensus::encode::Error> {
+        let byte_type = u8::consensus_decode(d)?;
         match byte_type {
             0x00 => Ok(BundleStatus::Init),
             0x01 => {
-                let num = VarInt::consensus_decode(&mut d)?;
+                let num = VarInt::consensus_decode(d)?;
                 let num = num.0 as usize;
 
                 let mut cf_headers = Vec::with_capacity(num);
                 for _ in 0..num {
-                    cf_headers.push(FilterHeader::consensus_decode(&mut d)?);
+                    cf_headers.push(FilterHeader::consensus_decode(d)?);
                 }
 
                 Ok(BundleStatus::CfHeaders { cf_headers })
             }
             0x02 => {
-                let num = VarInt::consensus_decode(&mut d)?;
+                let num = VarInt::consensus_decode(d)?;
                 let num = num.0 as usize;
 
                 let mut cf_filters = Vec::with_capacity(num);
                 for _ in 0..num {
-                    cf_filters.push(Vec::<u8>::consensus_decode(&mut d)?);
+                    cf_filters.push(Vec::<u8>::consensus_decode(d)?);
                 }
 
                 Ok(BundleStatus::CFilters { cf_filters })
             }
             0x03 => {
-                let num = VarInt::consensus_decode(&mut d)?;
+                let num = VarInt::consensus_decode(d)?;
                 let num = num.0 as usize;
 
                 let mut cf_filters = Vec::with_capacity(num);
                 for _ in 0..num {
-                    cf_filters.push(Vec::<u8>::consensus_decode(&mut d)?);
+                    cf_filters.push(Vec::<u8>::consensus_decode(d)?);
                 }
 
                 Ok(BundleStatus::Processed { cf_filters })
             }
             0x04 => Ok(BundleStatus::Pruned),
             0x05 => {
-                let num = VarInt::consensus_decode(&mut d)?;
+                let num = VarInt::consensus_decode(d)?;
                 let num = num.0 as usize;
 
                 let mut cf_filters = Vec::with_capacity(num);
                 for _ in 0..num {
-                    cf_filters.push(Vec::<u8>::consensus_decode(&mut d)?);
+                    cf_filters.push(Vec::<u8>::consensus_decode(d)?);
                 }
 
                 Ok(BundleStatus::Tip { cf_filters })
@@ -224,12 +216,7 @@ pub struct ChainStore<T: StoreType> {
 
 impl ChainStore<Full> {
     pub fn new(store: DB, network: Network) -> Result<Self, CompactFiltersError> {
-        let genesis = match network {
-            Network::Bitcoin => MAINNET_GENESIS.deref(),
-            Network::Testnet => TESTNET_GENESIS.deref(),
-            Network::Regtest => REGTEST_GENESIS.deref(),
-            Network::Signet => SIGNET_GENESIS.deref(),
-        };
+        let genesis = genesis_block(network);
 
         let cf_name = "default".to_string();
         let cf_handle = store.cf_handle(&cf_name).unwrap();
@@ -291,7 +278,11 @@ impl ChainStore<Full> {
     }
 
     pub fn start_snapshot(&self, from: usize) -> Result<ChainStore<Snapshot>, CompactFiltersError> {
-        let new_cf_name: String = thread_rng().sample_iter(&Alphanumeric).take(16).collect();
+        let new_cf_name: String = thread_rng()
+            .sample_iter(&Alphanumeric)
+            .map(|byte| byte as char)
+            .take(16)
+            .collect();
         let new_cf_name = format!("_headers:{}", new_cf_name);
 
         let mut write_store = self.store.write().unwrap();
@@ -647,14 +638,9 @@ impl CfStore {
             filter_type,
         };
 
-        let genesis = match headers_store.network {
-            Network::Bitcoin => MAINNET_GENESIS.deref(),
-            Network::Testnet => TESTNET_GENESIS.deref(),
-            Network::Regtest => REGTEST_GENESIS.deref(),
-            Network::Signet => SIGNET_GENESIS.deref(),
-        };
+        let genesis = genesis_block(headers_store.network);
 
-        let filter = BlockFilter::new_script_filter(genesis, |utxo| {
+        let filter = BlockFilter::new_script_filter(&genesis, |utxo| {
             Err(bitcoin::util::bip158::Error::UtxoMissing(*utxo))
         })?;
         let first_key = StoreEntry::CFilterTable((filter_type, Some(0))).get_key();
@@ -667,7 +653,7 @@ impl CfStore {
                     &first_key,
                     (
                         BundleStatus::Init,
-                        filter.filter_header(&FilterHeader::from_hash(Default::default())),
+                        filter.filter_header(&FilterHeader::from_hash(Hash::all_zeros())),
                     )
                         .serialize(),
                 )?;

src/blockchain/compact_filters/sync.rs

@@ -14,6 +14,7 @@ use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
 use bitcoin::hash_types::{BlockHash, FilterHeader};
+use bitcoin::hashes::Hash;
 use bitcoin::network::message::NetworkMessage;
 use bitcoin::network::message_blockdata::GetHeadersMessage;
 use bitcoin::util::bip158::BlockFilter;
@@ -254,7 +255,7 @@ where
 
     peer.send(NetworkMessage::GetHeaders(GetHeadersMessage::new(
         locators_vec,
-        Default::default(),
+        Hash::all_zeros(),
     )))?;
     let (mut snapshot, mut last_hash) = if let NetworkMessage::Headers(headers) = peer
         .recv("headers", Some(Duration::from_secs(TIMEOUT_SECS)))?
@@ -276,7 +277,7 @@ where
     while sync_height < peer.get_version().start_height as usize {
         peer.send(NetworkMessage::GetHeaders(GetHeadersMessage::new(
             vec![last_hash],
-            Default::default(),
+            Hash::all_zeros(),
         )))?;
         if let NetworkMessage::Headers(headers) = peer
             .recv("headers", Some(Duration::from_secs(TIMEOUT_SECS)))?

src/blockchain/electrum.rs

@@ -296,7 +296,7 @@ impl<'a, 'b, D: Database> TxCache<'a, 'b, D> {
 }
 
 /// Configuration for an [`ElectrumBlockchain`]
-#[derive(Debug, serde::Deserialize, serde::Serialize, Clone, PartialEq)]
+#[derive(Debug, serde::Deserialize, serde::Serialize, Clone, PartialEq, Eq)]
 pub struct ElectrumBlockchainConfig {
     /// URL of the Electrum server (such as ElectrumX, Esplora, BWT) may start with `ssl://` or `tcp://` and include a port
     ///

src/blockchain/esplora/api.rs

@@ -1,117 +0,0 @@
-//! structs from the esplora API
-//!
-//! see: <https://github.com/Blockstream/esplora/blob/master/API.md>
-use crate::BlockTime;
-use bitcoin::{OutPoint, Script, Transaction, TxIn, TxOut, Txid, Witness};
-
-#[derive(serde::Deserialize, Clone, Debug)]
-pub struct PrevOut {
-    pub value: u64,
-    pub scriptpubkey: Script,
-}
-
-#[derive(serde::Deserialize, Clone, Debug)]
-pub struct Vin {
-    pub txid: Txid,
-    pub vout: u32,
-    // None if coinbase
-    pub prevout: Option<PrevOut>,
-    pub scriptsig: Script,
-    #[serde(deserialize_with = "deserialize_witness", default)]
-    pub witness: Vec<Vec<u8>>,
-    pub sequence: u32,
-    pub is_coinbase: bool,
-}
-
-#[derive(serde::Deserialize, Clone, Debug)]
-pub struct Vout {
-    pub value: u64,
-    pub scriptpubkey: Script,
-}
-
-#[derive(serde::Deserialize, Clone, Debug)]
-pub struct TxStatus {
-    pub confirmed: bool,
-    pub block_height: Option<u32>,
-    pub block_time: Option<u64>,
-}
-
-#[derive(serde::Deserialize, Clone, Debug)]
-pub struct Tx {
-    pub txid: Txid,
-    pub version: i32,
-    pub locktime: u32,
-    pub vin: Vec<Vin>,
-    pub vout: Vec<Vout>,
-    pub status: TxStatus,
-    pub fee: u64,
-}
-
-impl Tx {
-    pub fn to_tx(&self) -> Transaction {
-        Transaction {
-            version: self.version,
-            lock_time: self.locktime,
-            input: self
-                .vin
-                .iter()
-                .cloned()
-                .map(|vin| TxIn {
-                    previous_output: OutPoint {
-                        txid: vin.txid,
-                        vout: vin.vout,
-                    },
-                    script_sig: vin.scriptsig,
-                    sequence: vin.sequence,
-                    witness: Witness::from_vec(vin.witness),
-                })
-                .collect(),
-            output: self
-                .vout
-                .iter()
-                .cloned()
-                .map(|vout| TxOut {
-                    value: vout.value,
-                    script_pubkey: vout.scriptpubkey,
-                })
-                .collect(),
-        }
-    }
-
-    pub fn confirmation_time(&self) -> Option<BlockTime> {
-        match self.status {
-            TxStatus {
-                confirmed: true,
-                block_height: Some(height),
-                block_time: Some(timestamp),
-            } => Some(BlockTime { timestamp, height }),
-            _ => None,
-        }
-    }
-
-    pub fn previous_outputs(&self) -> Vec<Option<TxOut>> {
-        self.vin
-            .iter()
-            .cloned()
-            .map(|vin| {
-                vin.prevout.map(|po| TxOut {
-                    script_pubkey: po.scriptpubkey,
-                    value: po.value,
-                })
-            })
-            .collect()
-    }
-}
-
-fn deserialize_witness<'de, D>(d: D) -> Result<Vec<Vec<u8>>, D::Error>
-where
-    D: serde::de::Deserializer<'de>,
-{
-    use crate::serde::Deserialize;
-    use bitcoin::hashes::hex::FromHex;
-    let list = Vec::<String>::deserialize(d)?;
-    list.into_iter()
-        .map(|hex_str| Vec::<u8>::from_hex(&hex_str))
-        .collect::<Result<Vec<Vec<u8>>, _>>()
-        .map_err(serde::de::Error::custom)
-}

src/blockchain/esplora/async.rs

@@ -14,49 +14,36 @@
 use std::collections::{HashMap, HashSet};
 use std::ops::Deref;
 
-use bitcoin::consensus::{deserialize, serialize};
-use bitcoin::hashes::hex::{FromHex, ToHex};
-use bitcoin::hashes::{sha256, Hash};
-use bitcoin::{BlockHeader, Script, Transaction, Txid};
+use bitcoin::{Transaction, Txid};
 
 #[allow(unused_imports)]
 use log::{debug, error, info, trace};
 
-use ::reqwest::{Client, StatusCode};
+use esplora_client::{convert_fee_rate, AsyncClient, Builder, Tx};
 use futures::stream::{FuturesOrdered, TryStreamExt};
 
-use super::api::Tx;
-use crate::blockchain::esplora::EsploraError;
 use crate::blockchain::*;
 use crate::database::BatchDatabase;
 use crate::error::Error;
 use crate::FeeRate;
 
-/// Structure encapsulates Esplora client
-#[derive(Debug)]
-pub struct UrlClient {
-    url: String,
-    // We use the async client instead of the blocking one because it automatically uses `fetch`
-    // when the target platform is wasm32.
-    client: Client,
-    concurrency: u8,
-}
-
 /// 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,
+    url_client: AsyncClient,
     stop_gap: usize,
+    concurrency: u8,
 }
 
-impl std::convert::From<UrlClient> for EsploraBlockchain {
-    fn from(url_client: UrlClient) -> Self {
+impl std::convert::From<AsyncClient> for EsploraBlockchain {
+    fn from(url_client: AsyncClient) -> Self {
         EsploraBlockchain {
             url_client,
             stop_gap: 20,
+            concurrency: super::DEFAULT_CONCURRENT_REQUESTS,
         }
     }
 }
@@ -64,19 +51,25 @@ impl std::convert::From<UrlClient> for EsploraBlockchain {
 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 {
+        let url_client = Builder::new(base_url)
+            .build_async()
+            .expect("Should never fail with no proxy and timeout");
+
+        Self::from_client(url_client, stop_gap)
+    }
+
+    /// Build a new instance given a client
+    pub fn from_client(url_client: AsyncClient, stop_gap: usize) -> Self {
         EsploraBlockchain {
-            url_client: UrlClient {
-                url: base_url.to_string(),
-                client: Client::new(),
-                concurrency: super::DEFAULT_CONCURRENT_REQUESTS,
-            },
+            url_client,
             stop_gap,
+            concurrency: super::DEFAULT_CONCURRENT_REQUESTS,
         }
     }
 
     /// 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.concurrency = concurrency;
         self
     }
 }
@@ -94,17 +87,19 @@ impl Blockchain for EsploraBlockchain {
     }
 
     fn broadcast(&self, tx: &Transaction) -> Result<(), Error> {
-        Ok(await_or_block!(self.url_client._broadcast(tx))?)
+        Ok(await_or_block!(self.url_client.broadcast(tx))?)
     }
 
     fn estimate_fee(&self, target: usize) -> Result<FeeRate, Error> {
-        let estimates = await_or_block!(self.url_client._get_fee_estimates())?;
-        super::into_fee_rate(target, estimates)
+        let estimates = await_or_block!(self.url_client.get_fee_estimates())?;
+        Ok(FeeRate::from_sat_per_vb(convert_fee_rate(
+            target, estimates,
+        )?))
     }
 }
 
 impl Deref for EsploraBlockchain {
-    type Target = UrlClient;
+    type Target = AsyncClient;
 
     fn deref(&self) -> &Self::Target {
         &self.url_client
@@ -116,22 +111,23 @@ impl StatelessBlockchain for EsploraBlockchain {}
 #[maybe_async]
 impl GetHeight for EsploraBlockchain {
     fn get_height(&self) -> Result<u32, Error> {
-        Ok(await_or_block!(self.url_client._get_height())?)
+        Ok(await_or_block!(self.url_client.get_height())?)
     }
 }
 
 #[maybe_async]
 impl GetTx for EsploraBlockchain {
     fn get_tx(&self, txid: &Txid) -> Result<Option<Transaction>, Error> {
-        Ok(await_or_block!(self.url_client._get_tx(txid))?)
+        Ok(await_or_block!(self.url_client.get_tx(txid))?)
     }
 }
 
 #[maybe_async]
 impl GetBlockHash for EsploraBlockchain {
     fn get_block_hash(&self, height: u64) -> Result<BlockHash, Error> {
-        let block_header = await_or_block!(self.url_client._get_header(height as u32))?;
-        Ok(block_header.block_hash())
+        Ok(await_or_block!(self
+            .url_client
+            .get_block_hash(height as u32))?)
     }
 }
 
@@ -151,10 +147,10 @@ impl WalletSync for EsploraBlockchain {
                 Request::Script(script_req) => {
                     let futures: FuturesOrdered<_> = script_req
                         .request()
-                        .take(self.url_client.concurrency as usize)
+                        .take(self.concurrency as usize)
                         .map(|script| async move {
                             let mut related_txs: Vec<Tx> =
-                                self.url_client._scripthash_txs(script, None).await?;
+                                self.url_client.scripthash_txs(script, None).await?;
 
                             let n_confirmed =
                                 related_txs.iter().filter(|tx| tx.status.confirmed).count();
@@ -164,7 +160,7 @@ impl WalletSync for EsploraBlockchain {
                                 loop {
                                     let new_related_txs: Vec<Tx> = self
                                         .url_client
-                                        ._scripthash_txs(
+                                        .scripthash_txs(
                                             script,
                                             Some(related_txs.last().unwrap().txid),
                                         )
@@ -204,6 +200,7 @@ impl WalletSync for EsploraBlockchain {
                                 .get(txid)
                                 .expect("must be in index")
                                 .confirmation_time()
+                                .map(Into::into)
                         })
                         .collect();
                     conftime_req.satisfy(conftimes)?
@@ -227,132 +224,26 @@ impl WalletSync for EsploraBlockchain {
     }
 }
 
-impl UrlClient {
-    async fn _get_tx(&self, txid: &Txid) -> Result<Option<Transaction>, EsploraError> {
-        let resp = self
-            .client
-            .get(&format!("{}/tx/{}/raw", self.url, txid))
-            .send()
-            .await?;
-
-        if let StatusCode::NOT_FOUND = resp.status() {
-            return Ok(None);
-        }
-
-        Ok(Some(deserialize(&resp.error_for_status()?.bytes().await?)?))
-    }
-
-    async fn _get_tx_no_opt(&self, txid: &Txid) -> Result<Transaction, EsploraError> {
-        match self._get_tx(txid).await {
-            Ok(Some(tx)) => Ok(tx),
-            Ok(None) => Err(EsploraError::TransactionNotFound(*txid)),
-            Err(e) => Err(e),
-        }
-    }
-
-    async fn _get_header(&self, block_height: u32) -> Result<BlockHeader, EsploraError> {
-        let resp = self
-            .client
-            .get(&format!("{}/block-height/{}", self.url, block_height))
-            .send()
-            .await?;
-
-        if let StatusCode::NOT_FOUND = resp.status() {
-            return Err(EsploraError::HeaderHeightNotFound(block_height));
-        }
-        let bytes = resp.bytes().await?;
-        let hash = std::str::from_utf8(&bytes)
-            .map_err(|_| EsploraError::HeaderHeightNotFound(block_height))?;
-
-        let resp = self
-            .client
-            .get(&format!("{}/block/{}/header", self.url, hash))
-            .send()
-            .await?;
-
-        let header = deserialize(&Vec::from_hex(&resp.text().await?)?)?;
-
-        Ok(header)
-    }
-
-    async fn _broadcast(&self, transaction: &Transaction) -> Result<(), EsploraError> {
-        self.client
-            .post(&format!("{}/tx", self.url))
-            .body(serialize(transaction).to_hex())
-            .send()
-            .await?
-            .error_for_status()?;
-
-        Ok(())
-    }
-
-    async fn _get_height(&self) -> Result<u32, EsploraError> {
-        let req = self
-            .client
-            .get(&format!("{}/blocks/tip/height", self.url))
-            .send()
-            .await?;
-
-        Ok(req.error_for_status()?.text().await?.parse()?)
-    }
-
-    async fn _scripthash_txs(
-        &self,
-        script: &Script,
-        last_seen: Option<Txid>,
-    ) -> Result<Vec<Tx>, EsploraError> {
-        let script_hash = sha256::Hash::hash(script.as_bytes()).into_inner().to_hex();
-        let url = match last_seen {
-            Some(last_seen) => format!(
-                "{}/scripthash/{}/txs/chain/{}",
-                self.url, script_hash, last_seen
-            ),
-            None => format!("{}/scripthash/{}/txs", self.url, script_hash),
-        };
-        Ok(self
-            .client
-            .get(url)
-            .send()
-            .await?
-            .error_for_status()?
-            .json::<Vec<Tx>>()
-            .await?)
-    }
-
-    async fn _get_fee_estimates(&self) -> Result<HashMap<String, f64>, EsploraError> {
-        Ok(self
-            .client
-            .get(&format!("{}/fee-estimates", self.url,))
-            .send()
-            .await?
-            .error_for_status()?
-            .json::<HashMap<String, f64>>()
-            .await?)
-    }
-}
-
 impl ConfigurableBlockchain for EsploraBlockchain {
     type Config = super::EsploraBlockchainConfig;
 
     fn from_config(config: &Self::Config) -> Result<Self, Error> {
-        let map_e = |e: reqwest::Error| Error::Esplora(Box::new(e.into()));
+        let mut builder = Builder::new(config.base_url.as_str());
 
-        let mut blockchain = EsploraBlockchain::new(config.base_url.as_str(), config.stop_gap);
-        if let Some(concurrency) = config.concurrency {
-            blockchain.url_client.concurrency = concurrency;
-        }
-        let mut builder = Client::builder();
-        #[cfg(not(target_arch = "wasm32"))]
-        if let Some(proxy) = &config.proxy {
-            builder = builder.proxy(reqwest::Proxy::all(proxy).map_err(map_e)?);
-        }
-
-        #[cfg(not(target_arch = "wasm32"))]
         if let Some(timeout) = config.timeout {
-            builder = builder.timeout(core::time::Duration::from_secs(timeout));
+            builder = builder.timeout(timeout);
         }
 
-        blockchain.url_client.client = builder.build().map_err(map_e)?;
+        if let Some(proxy) = &config.proxy {
+            builder = builder.proxy(proxy);
+        }
+
+        let mut blockchain =
+            EsploraBlockchain::from_client(builder.build_async()?, config.stop_gap);
+
+        if let Some(concurrency) = config.concurrency {
+            blockchain = blockchain.with_concurrency(concurrency);
+        }
 
         Ok(blockchain)
     }

src/blockchain/esplora/blocking.rs

@@ -12,42 +12,26 @@
 //! Esplora by way of `ureq` HTTP client.
 
 use std::collections::{HashMap, HashSet};
-use std::io;
-use std::io::Read;
-use std::ops::Deref;
-use std::time::Duration;
 
 #[allow(unused_imports)]
 use log::{debug, error, info, trace};
 
-use ureq::{Agent, Proxy, Response};
+use bitcoin::{Transaction, Txid};
 
-use bitcoin::consensus::{deserialize, serialize};
-use bitcoin::hashes::hex::{FromHex, ToHex};
-use bitcoin::hashes::{sha256, Hash};
-use bitcoin::{BlockHeader, Script, Transaction, Txid};
+use esplora_client::{convert_fee_rate, BlockingClient, Builder, Tx};
 
-use super::api::Tx;
-use crate::blockchain::esplora::EsploraError;
 use crate::blockchain::*;
 use crate::database::BatchDatabase;
 use crate::error::Error;
 use crate::FeeRate;
 
-/// Structure encapsulates ureq Esplora client
-#[derive(Debug, Clone)]
-pub 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,
+    url_client: BlockingClient,
     stop_gap: usize,
     concurrency: u8,
 }
@@ -55,22 +39,22 @@ pub struct EsploraBlockchain {
 impl EsploraBlockchain {
     /// Create a new instance of the client from a base URL and the `stop_gap`.
     pub fn new(base_url: &str, stop_gap: usize) -> Self {
+        let url_client = Builder::new(base_url)
+            .build_blocking()
+            .expect("Should never fail with no proxy and timeout");
+
+        Self::from_client(url_client, stop_gap)
+    }
+
+    /// Build a new instance given a client
+    pub fn from_client(url_client: BlockingClient, stop_gap: usize) -> Self {
         EsploraBlockchain {
-            url_client: UrlClient {
-                url: base_url.to_string(),
-                agent: Agent::new(),
-            },
+            url_client,
             concurrency: super::DEFAULT_CONCURRENT_REQUESTS,
             stop_gap,
         }
     }
 
-    /// Set the inner `ureq` agent.
-    pub fn with_agent(mut self, agent: Agent) -> Self {
-        self.url_client.agent = agent;
-        self
-    }
-
     /// Set the number of parallel requests the client can make.
     pub fn with_concurrency(mut self, concurrency: u8) -> Self {
         self.concurrency = concurrency;
@@ -90,18 +74,20 @@ impl Blockchain for EsploraBlockchain {
     }
 
     fn broadcast(&self, tx: &Transaction) -> Result<(), Error> {
-        self.url_client._broadcast(tx)?;
+        self.url_client.broadcast(tx)?;
         Ok(())
     }
 
     fn estimate_fee(&self, target: usize) -> Result<FeeRate, Error> {
-        let estimates = self.url_client._get_fee_estimates()?;
-        super::into_fee_rate(target, estimates)
+        let estimates = self.url_client.get_fee_estimates()?;
+        Ok(FeeRate::from_sat_per_vb(convert_fee_rate(
+            target, estimates,
+        )?))
     }
 }
 
 impl Deref for EsploraBlockchain {
-    type Target = UrlClient;
+    type Target = BlockingClient;
 
     fn deref(&self) -> &Self::Target {
         &self.url_client
@@ -112,20 +98,19 @@ impl StatelessBlockchain for EsploraBlockchain {}
 
 impl GetHeight for EsploraBlockchain {
     fn get_height(&self) -> Result<u32, Error> {
-        Ok(self.url_client._get_height()?)
+        Ok(self.url_client.get_height()?)
     }
 }
 
 impl GetTx for EsploraBlockchain {
     fn get_tx(&self, txid: &Txid) -> Result<Option<Transaction>, Error> {
-        Ok(self.url_client._get_tx(txid)?)
+        Ok(self.url_client.get_tx(txid)?)
     }
 }
 
 impl GetBlockHash for EsploraBlockchain {
     fn get_block_hash(&self, height: u64) -> Result<BlockHash, Error> {
-        let block_header = self.url_client._get_header(height as u32)?;
-        Ok(block_header.block_hash())
+        Ok(self.url_client.get_block_hash(height as u32)?)
     }
 }
 
@@ -151,7 +136,7 @@ impl WalletSync for EsploraBlockchain {
                         let client = self.url_client.clone();
                         // make each request in its own thread.
                         handles.push(std::thread::spawn(move || {
-                            let mut related_txs: Vec<Tx> = client._scripthash_txs(&script, None)?;
+                            let mut related_txs: Vec<Tx> = client.scripthash_txs(&script, None)?;
 
                             let n_confirmed =
                                 related_txs.iter().filter(|tx| tx.status.confirmed).count();
@@ -159,7 +144,7 @@ impl WalletSync for EsploraBlockchain {
                             // keep requesting to see if there's more.
                             if n_confirmed >= 25 {
                                 loop {
-                                    let new_related_txs: Vec<Tx> = client._scripthash_txs(
+                                    let new_related_txs: Vec<Tx> = client.scripthash_txs(
                                         &script,
                                         Some(related_txs.last().unwrap().txid),
                                     )?;
@@ -202,6 +187,7 @@ impl WalletSync for EsploraBlockchain {
                                 .get(txid)
                                 .expect("must be in index")
                                 .confirmation_time()
+                                .map(Into::into)
                         })
                         .collect();
                     conftime_req.satisfy(conftimes)?
@@ -226,159 +212,22 @@ impl WalletSync for EsploraBlockchain {
     }
 }
 
-impl UrlClient {
-    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 _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 _scripthash_txs(
-        &self,
-        script: &Script,
-        last_seen: Option<Txid>,
-    ) -> Result<Vec<Tx>, EsploraError> {
-        let script_hash = sha256::Hash::hash(script.as_bytes()).into_inner().to_hex();
-        let url = match last_seen {
-            Some(last_seen) => format!(
-                "{}/scripthash/{}/txs/chain/{}",
-                self.url, script_hash, last_seen
-            ),
-            None => format!("{}/scripthash/{}/txs", self.url, script_hash),
-        };
-        Ok(self.agent.get(&url).call()?.into_json()?)
-    }
-}
-
-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 ConfigurableBlockchain for EsploraBlockchain {
     type Config = super::EsploraBlockchainConfig;
 
     fn from_config(config: &Self::Config) -> Result<Self, Error> {
-        let mut agent_builder = ureq::AgentBuilder::new();
+        let mut builder = Builder::new(config.base_url.as_str());
 
         if let Some(timeout) = config.timeout {
-            agent_builder = agent_builder.timeout(Duration::from_secs(timeout));
+            builder = builder.timeout(timeout);
         }
 
         if let Some(proxy) = &config.proxy {
-            agent_builder = agent_builder
-                .proxy(Proxy::new(proxy).map_err(|e| Error::Esplora(Box::new(e.into())))?);
+            builder = builder.proxy(proxy);
         }
 
-        let mut blockchain = EsploraBlockchain::new(config.base_url.as_str(), config.stop_gap)
-            .with_agent(agent_builder.build());
+        let mut blockchain =
+            EsploraBlockchain::from_client(builder.build_blocking()?, config.stop_gap);
 
         if let Some(concurrency) = config.concurrency {
             blockchain = blockchain.with_concurrency(concurrency);
@@ -387,12 +236,3 @@ impl ConfigurableBlockchain for EsploraBlockchain {
         Ok(blockchain)
     }
 }
-
-impl From<ureq::Error> for EsploraError {
-    fn from(e: ureq::Error) -> Self {
-        match e {
-            ureq::Error::Status(code, _) => EsploraError::HttpResponse(code),
-            e => EsploraError::Ureq(e),
-        }
-    }
-}

src/blockchain/esplora/mod.rs

@@ -15,89 +15,25 @@
 //! 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;
+//! Blocking:  --features='use-esplora-blocking'
+//! Async:     --features='async-interface,use-esplora-async' --no-default-features
 
-use bitcoin::consensus;
-use bitcoin::{BlockHash, Txid};
+pub use esplora_client::Error as EsploraError;
 
-use crate::error::Error;
-use crate::FeeRate;
+#[cfg(feature = "use-esplora-async")]
+mod r#async;
 
-#[cfg(feature = "reqwest")]
-mod reqwest;
+#[cfg(feature = "use-esplora-async")]
+pub use self::r#async::*;
 
-#[cfg(feature = "reqwest")]
-pub use self::reqwest::*;
+#[cfg(feature = "use-esplora-blocking")]
+mod blocking;
 
-#[cfg(feature = "ureq")]
-mod ureq;
-
-#[cfg(feature = "ureq")]
-pub use self::ureq::*;
-
-mod api;
-
-fn into_fee_rate(target: usize, estimates: HashMap<String, f64>) -> Result<FeeRate, Error> {
-    let fee_val = {
-        let mut pairs = estimates
-            .into_iter()
-            .filter_map(|(k, v)| Some((k.parse::<usize>().ok()?, v)))
-            .collect::<Vec<_>>();
-        pairs.sort_unstable_by_key(|(k, _)| std::cmp::Reverse(*k));
-        pairs
-            .into_iter()
-            .find(|(k, _)| k <= &target)
-            .map(|(_, v)| v)
-            .unwrap_or(1.0)
-    };
-    Ok(FeeRate::from_sat_per_vb(fee_val as f32))
-}
-
-/// 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)
-    }
-}
+#[cfg(feature = "use-esplora-blocking")]
+pub use self::blocking::*;
 
 /// Configuration for an [`EsploraBlockchain`]
-#[derive(Debug, serde::Deserialize, serde::Serialize, Clone, PartialEq)]
+#[derive(Debug, serde::Deserialize, serde::Serialize, Clone, PartialEq, Eq)]
 pub struct EsploraBlockchainConfig {
     /// Base URL of the esplora service
     ///
@@ -138,16 +74,11 @@ impl EsploraBlockchainConfig {
     }
 }
 
-impl std::error::Error for 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);
+impl From<esplora_client::BlockTime> for crate::BlockTime {
+    fn from(esplora_client::BlockTime { timestamp, height }: esplora_client::BlockTime) -> Self {
+        Self { timestamp, height }
+    }
+}
 
 #[cfg(test)]
 #[cfg(feature = "test-esplora")]
@@ -161,58 +92,11 @@ const DEFAULT_CONCURRENT_REQUESTS: u8 = 4;
 
 #[cfg(test)]
 mod test {
-    use super::*;
-
-    #[test]
-    fn feerate_parsing() {
-        let esplora_fees = serde_json::from_str::<HashMap<String, f64>>(
-            r#"{
-  "25": 1.015,
-  "5": 2.3280000000000003,
-  "12": 2.0109999999999997,
-  "15": 1.018,
-  "17": 1.018,
-  "11": 2.0109999999999997,
-  "3": 3.01,
-  "2": 4.9830000000000005,
-  "6": 2.2359999999999998,
-  "21": 1.018,
-  "13": 1.081,
-  "7": 2.2359999999999998,
-  "8": 2.2359999999999998,
-  "16": 1.018,
-  "20": 1.018,
-  "22": 1.017,
-  "23": 1.017,
-  "504": 1,
-  "9": 2.2359999999999998,
-  "14": 1.018,
-  "10": 2.0109999999999997,
-  "24": 1.017,
-  "1008": 1,
-  "1": 4.9830000000000005,
-  "4": 2.3280000000000003,
-  "19": 1.018,
-  "144": 1,
-  "18": 1.018
-}
-"#,
-        )
-        .unwrap();
-        assert_eq!(
-            into_fee_rate(6, esplora_fees.clone()).unwrap(),
-            FeeRate::from_sat_per_vb(2.236)
-        );
-        assert_eq!(
-            into_fee_rate(26, esplora_fees).unwrap(),
-            FeeRate::from_sat_per_vb(1.015),
-            "should inherit from value for 25"
-        );
-    }
-
     #[test]
     #[cfg(feature = "test-esplora")]
     fn test_esplora_with_variable_configs() {
+        use super::*;
+
         use crate::testutils::{
             blockchain_tests::TestClient,
             configurable_blockchain_tests::ConfigurableBlockchainTester,

src/blockchain/rpc.rs

@@ -35,7 +35,7 @@ use crate::bitcoin::hashes::hex::ToHex;
 use crate::bitcoin::{Network, OutPoint, Transaction, TxOut, Txid};
 use crate::blockchain::*;
 use crate::database::{BatchDatabase, BatchOperations, DatabaseUtils};
-use crate::descriptor::get_checksum;
+use crate::descriptor::calc_checksum;
 use crate::error::MissingCachedScripts;
 use crate::{BlockTime, Error, FeeRate, KeychainKind, LocalUtxo, TransactionDetails};
 use bitcoin::Script;
@@ -77,7 +77,7 @@ impl Deref for RpcBlockchain {
 }
 
 /// RpcBlockchain configuration options
-#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
 pub struct RpcConfig {
     /// The bitcoin node url
     pub url: String,
@@ -96,7 +96,7 @@ pub struct RpcConfig {
 /// In general, BDK tries to sync `scriptPubKey`s cached in [`crate::database::Database`] with
 /// `scriptPubKey`s imported in the Bitcoin Core Wallet. These parameters are used for determining
 /// how the `importdescriptors` RPC calls are to be made.
-#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
 pub struct RpcSyncParams {
     /// The minimum number of scripts to scan for on initial sync.
     pub start_script_count: usize,
@@ -167,7 +167,7 @@ impl Blockchain for RpcBlockchain {
             .estimate_smart_fee(target as u16, None)?
             .fee_rate
             .ok_or(Error::FeeRateUnavailable)?
-            .as_sat() as f64;
+            .to_sat() as f64;
 
         Ok(FeeRate::from_sat_per_vb((sat_per_kb / 1000f64) as f32))
     }
@@ -410,7 +410,12 @@ impl<'a, D: BatchDatabase> DbState<'a, D> {
                 updated = true;
                 TransactionDetails {
                     txid: tx_res.info.txid,
-                    ..Default::default()
+                    transaction: None,
+
+                    received: 0,
+                    sent: 0,
+                    fee: None,
+                    confirmation_time: None,
                 }
             });
 
@@ -430,7 +435,7 @@ impl<'a, D: BatchDatabase> DbState<'a, D> {
             // update fee (if needed)
             if let (None, Some(new_fee)) = (db_tx.fee, tx_res.detail.fee) {
                 updated = true;
-                db_tx.fee = Some(new_fee.as_sat().unsigned_abs());
+                db_tx.fee = Some(new_fee.to_sat().unsigned_abs());
             }
 
             // update confirmation time (if needed)
@@ -603,7 +608,7 @@ impl<'a, D: BatchDatabase> DbState<'a, D> {
         LocalUtxo {
             outpoint: OutPoint::new(entry.txid, entry.vout),
             txout: TxOut {
-                value: entry.amount.as_sat(),
+                value: entry.amount.to_sat(),
                 script_pubkey: entry.script_pub_key,
             },
             keychain,
@@ -801,7 +806,7 @@ fn is_wallet_descriptor(client: &Client) -> Result<bool, Error> {
 
 fn descriptor_from_script_pubkey(script: &Script) -> String {
     let desc = format!("raw({})", script.to_hex());
-    format!("{}#{}", desc, get_checksum(&desc).unwrap())
+    format!("{}#{}", desc, calc_checksum(&desc).unwrap())
 }
 
 /// Factory of [`RpcBlockchain`] instances, implements [`BlockchainFactory`]
@@ -873,15 +878,13 @@ impl BlockchainFactory for RpcBlockchainFactory {
 mod test {
     use super::*;
     use crate::{
-        descriptor::{into_wallet_descriptor_checked, AsDerived},
-        testutils::blockchain_tests::TestClient,
+        descriptor::into_wallet_descriptor_checked, testutils::blockchain_tests::TestClient,
         wallet::utils::SecpCtx,
     };
 
     use bitcoin::{Address, Network};
     use bitcoincore_rpc::RpcApi;
     use log::LevelFilter;
-    use miniscript::DescriptorTrait;
 
     crate::bdk_blockchain_tests! {
         fn test_instance(test_client: &TestClient) -> RpcBlockchain {
@@ -958,7 +961,7 @@ mod test {
 
         // generate scripts (1 tx per script)
         let scripts = (0..TX_COUNT)
-            .map(|index| desc.as_derived(index, &secp).script_pubkey())
+            .map(|index| desc.at_derivation_index(index).script_pubkey())
             .collect::<Vec<_>>();
 
         // import scripts and wait

src/database/keyvalue.rs

@@ -492,4 +492,44 @@ mod test {
     fn test_sync_time() {
         crate::database::test::test_sync_time(get_tree());
     }
+
+    #[test]
+    fn test_iter_raw_txs() {
+        crate::database::test::test_iter_raw_txs(get_tree());
+    }
+
+    #[test]
+    fn test_del_path_from_script_pubkey() {
+        crate::database::test::test_del_path_from_script_pubkey(get_tree());
+    }
+
+    #[test]
+    fn test_iter_script_pubkeys() {
+        crate::database::test::test_iter_script_pubkeys(get_tree());
+    }
+
+    #[test]
+    fn test_del_utxo() {
+        crate::database::test::test_del_utxo(get_tree());
+    }
+
+    #[test]
+    fn test_del_raw_tx() {
+        crate::database::test::test_del_raw_tx(get_tree());
+    }
+
+    #[test]
+    fn test_del_tx() {
+        crate::database::test::test_del_tx(get_tree());
+    }
+
+    #[test]
+    fn test_del_last_index() {
+        crate::database::test::test_del_last_index(get_tree());
+    }
+
+    #[test]
+    fn test_check_descriptor_checksum() {
+        crate::database::test::test_check_descriptor_checksum(get_tree());
+    }
 }

src/database/memory.rs

@@ -497,7 +497,7 @@ macro_rules! populate_test_db {
         }
         let tx = $crate::bitcoin::Transaction {
             version: 1,
-            lock_time: 0,
+            lock_time: bitcoin::PackedLockTime(0),
             input,
             output: tx_meta
                 .output
@@ -647,4 +647,44 @@ mod test {
     fn test_sync_time() {
         crate::database::test::test_sync_time(get_tree());
     }
+
+    #[test]
+    fn test_iter_raw_txs() {
+        crate::database::test::test_iter_raw_txs(get_tree());
+    }
+
+    #[test]
+    fn test_del_path_from_script_pubkey() {
+        crate::database::test::test_del_path_from_script_pubkey(get_tree());
+    }
+
+    #[test]
+    fn test_iter_script_pubkeys() {
+        crate::database::test::test_iter_script_pubkeys(get_tree());
+    }
+
+    #[test]
+    fn test_del_utxo() {
+        crate::database::test::test_del_utxo(get_tree());
+    }
+
+    #[test]
+    fn test_del_raw_tx() {
+        crate::database::test::test_del_raw_tx(get_tree());
+    }
+
+    #[test]
+    fn test_del_tx() {
+        crate::database::test::test_del_tx(get_tree());
+    }
+
+    #[test]
+    fn test_del_last_index() {
+        crate::database::test::test_del_last_index(get_tree());
+    }
+
+    #[test]
+    fn test_check_descriptor_checksum() {
+        crate::database::test::test_check_descriptor_checksum(get_tree());
+    }
 }

src/database/mod.rs

@@ -217,32 +217,33 @@ pub mod test {
     use std::str::FromStr;
 
     use bitcoin::consensus::encode::deserialize;
+    use bitcoin::consensus::serialize;
     use bitcoin::hashes::hex::*;
     use bitcoin::*;
 
     use super::*;
 
-    pub fn test_script_pubkey<D: Database>(mut tree: D) {
+    pub fn test_script_pubkey<D: Database>(mut db: D) {
         let script = Script::from(
             Vec::<u8>::from_hex("76a91402306a7c23f3e8010de41e9e591348bb83f11daa88ac").unwrap(),
         );
         let path = 42;
         let keychain = KeychainKind::External;
 
-        tree.set_script_pubkey(&script, keychain, path).unwrap();
+        db.set_script_pubkey(&script, keychain, path).unwrap();
 
         assert_eq!(
-            tree.get_script_pubkey_from_path(keychain, path).unwrap(),
+            db.get_script_pubkey_from_path(keychain, path).unwrap(),
             Some(script.clone())
         );
         assert_eq!(
-            tree.get_path_from_script_pubkey(&script).unwrap(),
+            db.get_path_from_script_pubkey(&script).unwrap(),
             Some((keychain, path))
         );
     }
 
-    pub fn test_batch_script_pubkey<D: BatchDatabase>(mut tree: D) {
-        let mut batch = tree.begin_batch();
+    pub fn test_batch_script_pubkey<D: BatchDatabase>(mut db: D) {
+        let mut batch = db.begin_batch();
 
         let script = Script::from(
             Vec::<u8>::from_hex("76a91402306a7c23f3e8010de41e9e591348bb83f11daa88ac").unwrap(),
@@ -253,50 +254,50 @@ pub mod test {
         batch.set_script_pubkey(&script, keychain, path).unwrap();
 
         assert_eq!(
-            tree.get_script_pubkey_from_path(keychain, path).unwrap(),
+            db.get_script_pubkey_from_path(keychain, path).unwrap(),
             None
         );
-        assert_eq!(tree.get_path_from_script_pubkey(&script).unwrap(), None);
+        assert_eq!(db.get_path_from_script_pubkey(&script).unwrap(), None);
 
-        tree.commit_batch(batch).unwrap();
+        db.commit_batch(batch).unwrap();
 
         assert_eq!(
-            tree.get_script_pubkey_from_path(keychain, path).unwrap(),
+            db.get_script_pubkey_from_path(keychain, path).unwrap(),
             Some(script.clone())
         );
         assert_eq!(
-            tree.get_path_from_script_pubkey(&script).unwrap(),
+            db.get_path_from_script_pubkey(&script).unwrap(),
             Some((keychain, path))
         );
     }
 
-    pub fn test_iter_script_pubkey<D: Database>(mut tree: D) {
+    pub fn test_iter_script_pubkey<D: Database>(mut db: D) {
         let script = Script::from(
             Vec::<u8>::from_hex("76a91402306a7c23f3e8010de41e9e591348bb83f11daa88ac").unwrap(),
         );
         let path = 42;
         let keychain = KeychainKind::External;
 
-        tree.set_script_pubkey(&script, keychain, path).unwrap();
+        db.set_script_pubkey(&script, keychain, path).unwrap();
 
-        assert_eq!(tree.iter_script_pubkeys(None).unwrap().len(), 1);
+        assert_eq!(db.iter_script_pubkeys(None).unwrap().len(), 1);
     }
 
-    pub fn test_del_script_pubkey<D: Database>(mut tree: D) {
+    pub fn test_del_script_pubkey<D: Database>(mut db: D) {
         let script = Script::from(
             Vec::<u8>::from_hex("76a91402306a7c23f3e8010de41e9e591348bb83f11daa88ac").unwrap(),
         );
         let path = 42;
         let keychain = KeychainKind::External;
 
-        tree.set_script_pubkey(&script, keychain, path).unwrap();
-        assert_eq!(tree.iter_script_pubkeys(None).unwrap().len(), 1);
+        db.set_script_pubkey(&script, keychain, path).unwrap();
+        assert_eq!(db.iter_script_pubkeys(None).unwrap().len(), 1);
 
-        tree.del_script_pubkey_from_path(keychain, path).unwrap();
-        assert_eq!(tree.iter_script_pubkeys(None).unwrap().len(), 0);
+        db.del_script_pubkey_from_path(keychain, path).unwrap();
+        assert_eq!(db.iter_script_pubkeys(None).unwrap().len(), 0);
     }
 
-    pub fn test_utxo<D: Database>(mut tree: D) {
+    pub fn test_utxo<D: Database>(mut db: D) {
         let outpoint = OutPoint::from_str(
             "5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456:0",
         )
@@ -315,24 +316,40 @@ pub mod test {
             is_spent: true,
         };
 
-        tree.set_utxo(&utxo).unwrap();
-        tree.set_utxo(&utxo).unwrap();
-        assert_eq!(tree.iter_utxos().unwrap().len(), 1);
-        assert_eq!(tree.get_utxo(&outpoint).unwrap(), Some(utxo));
+        db.set_utxo(&utxo).unwrap();
+        db.set_utxo(&utxo).unwrap();
+        assert_eq!(db.iter_utxos().unwrap().len(), 1);
+        assert_eq!(db.get_utxo(&outpoint).unwrap(), Some(utxo));
     }
 
-    pub fn test_raw_tx<D: Database>(mut tree: D) {
-        let hex_tx = Vec::<u8>::from_hex("0100000001a15d57094aa7a21a28cb20b59aab8fc7d1149a3bdbcddba9c622e4f5f6a99ece010000006c493046022100f93bb0e7d8db7bd46e40132d1f8242026e045f03a0efe71bbb8e3f475e970d790221009337cd7f1f929f00cc6ff01f03729b069a7c21b59b1736ddfee5db5946c5da8c0121033b9b137ee87d5a812d6f506efdd37f0affa7ffc310711c06c7f3e097c9447c52ffffffff0100e1f505000000001976a9140389035a9225b3839e2bbf32d826a1e222031fd888ac00000000").unwrap();
-        let tx: Transaction = deserialize(&hex_tx).unwrap();
+    pub fn test_raw_tx<D: Database>(mut db: D) {
+        let hex_tx = Vec::<u8>::from_hex("02000000000101f58c18a90d7a76b30c7e47d4e817adfdd79a6a589a615ef36e360f913adce2cd0000000000feffffff0210270000000000001600145c9a1816d38db5cbdd4b067b689dc19eb7d930e2cf70aa2b080000001600140f48b63160043047f4f60f7f8f551f80458f693f024730440220413f42b7bc979945489a38f5221e5527d4b8e3aa63eae2099e01945896ad6c10022024ceec492d685c31d8adb64e935a06933877c5ae0e21f32efe029850914c5bad012102361caae96f0e9f3a453d354bb37a5c3244422fb22819bf0166c0647a38de39f21fca2300").unwrap();
+        let mut tx: Transaction = deserialize(&hex_tx).unwrap();
 
-        tree.set_raw_tx(&tx).unwrap();
+        db.set_raw_tx(&tx).unwrap();
 
         let txid = tx.txid();
 
-        assert_eq!(tree.get_raw_tx(&txid).unwrap(), Some(tx));
+        assert_eq!(db.get_raw_tx(&txid).unwrap(), Some(tx.clone()));
+
+        // mutate transaction's witnesses
+        for tx_in in tx.input.iter_mut() {
+            tx_in.witness = Witness::new();
+        }
+
+        let updated_hex_tx = serialize(&tx);
+
+        // verify that mutation was successful
+        assert_ne!(hex_tx, updated_hex_tx);
+
+        db.set_raw_tx(&tx).unwrap();
+
+        let txid = tx.txid();
+
+        assert_eq!(db.get_raw_tx(&txid).unwrap(), Some(tx));
     }
 
-    pub fn test_tx<D: Database>(mut tree: D) {
+    pub fn test_tx<D: Database>(mut db: D) {
         let hex_tx = Vec::<u8>::from_hex("0100000001a15d57094aa7a21a28cb20b59aab8fc7d1149a3bdbcddba9c622e4f5f6a99ece010000006c493046022100f93bb0e7d8db7bd46e40132d1f8242026e045f03a0efe71bbb8e3f475e970d790221009337cd7f1f929f00cc6ff01f03729b069a7c21b59b1736ddfee5db5946c5da8c0121033b9b137ee87d5a812d6f506efdd37f0affa7ffc310711c06c7f3e097c9447c52ffffffff0100e1f505000000001976a9140389035a9225b3839e2bbf32d826a1e222031fd888ac00000000").unwrap();
         let tx: Transaction = deserialize(&hex_tx).unwrap();
         let txid = tx.txid();
@@ -348,28 +365,28 @@ pub mod test {
             }),
         };
 
-        tree.set_tx(&tx_details).unwrap();
+        db.set_tx(&tx_details).unwrap();
 
         // get with raw tx too
         assert_eq!(
-            tree.get_tx(&tx_details.txid, true).unwrap(),
+            db.get_tx(&tx_details.txid, true).unwrap(),
             Some(tx_details.clone())
         );
         // get only raw_tx
         assert_eq!(
-            tree.get_raw_tx(&tx_details.txid).unwrap(),
+            db.get_raw_tx(&tx_details.txid).unwrap(),
             tx_details.transaction
         );
 
         // now get without raw_tx
         tx_details.transaction = None;
         assert_eq!(
-            tree.get_tx(&tx_details.txid, false).unwrap(),
+            db.get_tx(&tx_details.txid, false).unwrap(),
             Some(tx_details)
         );
     }
 
-    pub fn test_list_transaction<D: Database>(mut tree: D) {
+    pub fn test_list_transaction<D: Database>(mut db: D) {
         let hex_tx = Vec::<u8>::from_hex("0100000001a15d57094aa7a21a28cb20b59aab8fc7d1149a3bdbcddba9c622e4f5f6a99ece010000006c493046022100f93bb0e7d8db7bd46e40132d1f8242026e045f03a0efe71bbb8e3f475e970d790221009337cd7f1f929f00cc6ff01f03729b069a7c21b59b1736ddfee5db5946c5da8c0121033b9b137ee87d5a812d6f506efdd37f0affa7ffc310711c06c7f3e097c9447c52ffffffff0100e1f505000000001976a9140389035a9225b3839e2bbf32d826a1e222031fd888ac00000000").unwrap();
         let tx: Transaction = deserialize(&hex_tx).unwrap();
         let txid = tx.txid();
@@ -385,46 +402,43 @@ pub mod test {
             }),
         };
 
-        tree.set_tx(&tx_details).unwrap();
+        db.set_tx(&tx_details).unwrap();
 
         // get raw tx
-        assert_eq!(tree.iter_txs(true).unwrap(), vec![tx_details.clone()]);
+        assert_eq!(db.iter_txs(true).unwrap(), vec![tx_details.clone()]);
 
         // now get without raw tx
         tx_details.transaction = None;
 
         // get not raw tx
-        assert_eq!(tree.iter_txs(false).unwrap(), vec![tx_details.clone()]);
+        assert_eq!(db.iter_txs(false).unwrap(), vec![tx_details.clone()]);
     }
 
-    pub fn test_last_index<D: Database>(mut tree: D) {
-        tree.set_last_index(KeychainKind::External, 1337).unwrap();
+    pub fn test_last_index<D: Database>(mut db: D) {
+        db.set_last_index(KeychainKind::External, 1337).unwrap();
 
         assert_eq!(
-            tree.get_last_index(KeychainKind::External).unwrap(),
+            db.get_last_index(KeychainKind::External).unwrap(),
             Some(1337)
         );
-        assert_eq!(tree.get_last_index(KeychainKind::Internal).unwrap(), None);
+        assert_eq!(db.get_last_index(KeychainKind::Internal).unwrap(), None);
 
-        let res = tree.increment_last_index(KeychainKind::External).unwrap();
+        let res = db.increment_last_index(KeychainKind::External).unwrap();
         assert_eq!(res, 1338);
-        let res = tree.increment_last_index(KeychainKind::Internal).unwrap();
+        let res = db.increment_last_index(KeychainKind::Internal).unwrap();
         assert_eq!(res, 0);
 
         assert_eq!(
-            tree.get_last_index(KeychainKind::External).unwrap(),
+            db.get_last_index(KeychainKind::External).unwrap(),
             Some(1338)
         );
-        assert_eq!(
-            tree.get_last_index(KeychainKind::Internal).unwrap(),
-            Some(0)
-        );
+        assert_eq!(db.get_last_index(KeychainKind::Internal).unwrap(), Some(0));
     }
 
-    pub fn test_sync_time<D: Database>(mut tree: D) {
-        assert!(tree.get_sync_time().unwrap().is_none());
+    pub fn test_sync_time<D: Database>(mut db: D) {
+        assert!(db.get_sync_time().unwrap().is_none());
 
-        tree.set_sync_time(SyncTime {
+        db.set_sync_time(SyncTime {
             block_time: BlockTime {
                 height: 100,
                 timestamp: 1000,
@@ -432,13 +446,211 @@ pub mod test {
         })
         .unwrap();
 
-        let extracted = tree.get_sync_time().unwrap();
+        let extracted = db.get_sync_time().unwrap();
         assert!(extracted.is_some());
         assert_eq!(extracted.as_ref().unwrap().block_time.height, 100);
         assert_eq!(extracted.as_ref().unwrap().block_time.timestamp, 1000);
 
-        tree.del_sync_time().unwrap();
-        assert!(tree.get_sync_time().unwrap().is_none());
+        db.del_sync_time().unwrap();
+        assert!(db.get_sync_time().unwrap().is_none());
+    }
+
+    pub fn test_iter_raw_txs<D: Database>(mut db: D) {
+        let txs = db.iter_raw_txs().unwrap();
+        assert!(txs.is_empty());
+
+        let hex_tx = Vec::<u8>::from_hex("0100000001a15d57094aa7a21a28cb20b59aab8fc7d1149a3bdbcddba9c622e4f5f6a99ece010000006c493046022100f93bb0e7d8db7bd46e40132d1f8242026e045f03a0efe71bbb8e3f475e970d790221009337cd7f1f929f00cc6ff01f03729b069a7c21b59b1736ddfee5db5946c5da8c0121033b9b137ee87d5a812d6f506efdd37f0affa7ffc310711c06c7f3e097c9447c52ffffffff0100e1f505000000001976a9140389035a9225b3839e2bbf32d826a1e222031fd888ac00000000").unwrap();
+        let first_tx: Transaction = deserialize(&hex_tx).unwrap();
+
+        let hex_tx = Vec::<u8>::from_hex("02000000000101f58c18a90d7a76b30c7e47d4e817adfdd79a6a589a615ef36e360f913adce2cd0000000000feffffff0210270000000000001600145c9a1816d38db5cbdd4b067b689dc19eb7d930e2cf70aa2b080000001600140f48b63160043047f4f60f7f8f551f80458f693f024730440220413f42b7bc979945489a38f5221e5527d4b8e3aa63eae2099e01945896ad6c10022024ceec492d685c31d8adb64e935a06933877c5ae0e21f32efe029850914c5bad012102361caae96f0e9f3a453d354bb37a5c3244422fb22819bf0166c0647a38de39f21fca2300").unwrap();
+        let second_tx: Transaction = deserialize(&hex_tx).unwrap();
+
+        db.set_raw_tx(&first_tx).unwrap();
+        db.set_raw_tx(&second_tx).unwrap();
+
+        let txs = db.iter_raw_txs().unwrap();
+
+        assert!(txs.contains(&first_tx));
+        assert!(txs.contains(&second_tx));
+        assert_eq!(txs.len(), 2);
+    }
+
+    pub fn test_del_path_from_script_pubkey<D: Database>(mut db: D) {
+        let keychain = KeychainKind::External;
+
+        let script = Script::from(
+            Vec::<u8>::from_hex("76a91402306a7c23f3e8010de41e9e591348bb83f11daa88ac").unwrap(),
+        );
+        let path = 42;
+
+        let res = db.del_path_from_script_pubkey(&script).unwrap();
+
+        assert!(res.is_none());
+
+        let _res = db.set_script_pubkey(&script, keychain, path);
+        let (chain, child) = db.del_path_from_script_pubkey(&script).unwrap().unwrap();
+
+        assert_eq!(chain, keychain);
+        assert_eq!(child, path);
+
+        let res = db.get_path_from_script_pubkey(&script).unwrap();
+        assert!(res.is_none());
+    }
+
+    pub fn test_iter_script_pubkeys<D: Database>(mut db: D) {
+        let keychain = KeychainKind::External;
+        let scripts = db.iter_script_pubkeys(Some(keychain)).unwrap();
+        assert!(scripts.is_empty());
+
+        let first_script = Script::from(
+            Vec::<u8>::from_hex("76a91402306a7c23f3e8010de41e9e591348bb83f11daa88ac").unwrap(),
+        );
+        let path = 42;
+
+        db.set_script_pubkey(&first_script, keychain, path).unwrap();
+
+        let second_script = Script::from(
+            Vec::<u8>::from_hex("00145c9a1816d38db5cbdd4b067b689dc19eb7d930e2").unwrap(),
+        );
+        let path = 57;
+
+        db.set_script_pubkey(&second_script, keychain, path)
+            .unwrap();
+        let scripts = db.iter_script_pubkeys(Some(keychain)).unwrap();
+
+        assert!(scripts.contains(&first_script));
+        assert!(scripts.contains(&second_script));
+        assert_eq!(scripts.len(), 2);
+    }
+
+    pub fn test_del_utxo<D: Database>(mut db: D) {
+        let outpoint = OutPoint::from_str(
+            "5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456:0",
+        )
+        .unwrap();
+        let script = Script::from(
+            Vec::<u8>::from_hex("76a91402306a7c23f3e8010de41e9e591348bb83f11daa88ac").unwrap(),
+        );
+        let txout = TxOut {
+            value: 133742,
+            script_pubkey: script,
+        };
+        let utxo = LocalUtxo {
+            txout,
+            outpoint,
+            keychain: KeychainKind::External,
+            is_spent: true,
+        };
+
+        let res = db.del_utxo(&outpoint).unwrap();
+        assert!(res.is_none());
+
+        db.set_utxo(&utxo).unwrap();
+
+        let res = db.del_utxo(&outpoint).unwrap();
+
+        assert_eq!(res.unwrap(), utxo);
+
+        let res = db.get_utxo(&outpoint).unwrap();
+        assert!(res.is_none());
+    }
+
+    pub fn test_del_raw_tx<D: Database>(mut db: D) {
+        let hex_tx = Vec::<u8>::from_hex("02000000000101f58c18a90d7a76b30c7e47d4e817adfdd79a6a589a615ef36e360f913adce2cd0000000000feffffff0210270000000000001600145c9a1816d38db5cbdd4b067b689dc19eb7d930e2cf70aa2b080000001600140f48b63160043047f4f60f7f8f551f80458f693f024730440220413f42b7bc979945489a38f5221e5527d4b8e3aa63eae2099e01945896ad6c10022024ceec492d685c31d8adb64e935a06933877c5ae0e21f32efe029850914c5bad012102361caae96f0e9f3a453d354bb37a5c3244422fb22819bf0166c0647a38de39f21fca2300").unwrap();
+        let tx: Transaction = deserialize(&hex_tx).unwrap();
+
+        let res = db.del_raw_tx(&tx.txid()).unwrap();
+
+        assert!(res.is_none());
+
+        db.set_raw_tx(&tx).unwrap();
+
+        let res = db.del_raw_tx(&tx.txid()).unwrap();
+
+        assert_eq!(res.unwrap(), tx);
+
+        let res = db.get_raw_tx(&tx.txid()).unwrap();
+        assert!(res.is_none());
+    }
+
+    pub fn test_del_tx<D: Database>(mut db: D) {
+        let hex_tx = Vec::<u8>::from_hex("0100000001a15d57094aa7a21a28cb20b59aab8fc7d1149a3bdbcddba9c622e4f5f6a99ece010000006c493046022100f93bb0e7d8db7bd46e40132d1f8242026e045f03a0efe71bbb8e3f475e970d790221009337cd7f1f929f00cc6ff01f03729b069a7c21b59b1736ddfee5db5946c5da8c0121033b9b137ee87d5a812d6f506efdd37f0affa7ffc310711c06c7f3e097c9447c52ffffffff0100e1f505000000001976a9140389035a9225b3839e2bbf32d826a1e222031fd888ac00000000").unwrap();
+        let tx: Transaction = deserialize(&hex_tx).unwrap();
+        let txid = tx.txid();
+        let mut tx_details = TransactionDetails {
+            transaction: Some(tx.clone()),
+            txid,
+            received: 1337,
+            sent: 420420,
+            fee: Some(140),
+            confirmation_time: Some(BlockTime {
+                timestamp: 123456,
+                height: 1000,
+            }),
+        };
+
+        let res = db.del_tx(&tx.txid(), true).unwrap();
+
+        assert!(res.is_none());
+
+        db.set_tx(&tx_details).unwrap();
+
+        let res = db.del_tx(&tx.txid(), false).unwrap();
+        tx_details.transaction = None;
+        assert_eq!(res.unwrap(), tx_details);
+
+        let res = db.get_tx(&tx.txid(), true).unwrap();
+        assert!(res.is_none());
+
+        let res = db.get_raw_tx(&tx.txid()).unwrap();
+        assert_eq!(res.unwrap(), tx);
+
+        db.set_tx(&tx_details).unwrap();
+        let res = db.del_tx(&tx.txid(), true).unwrap();
+        tx_details.transaction = Some(tx.clone());
+        assert_eq!(res.unwrap(), tx_details);
+
+        let res = db.get_tx(&tx.txid(), true).unwrap();
+        assert!(res.is_none());
+
+        let res = db.get_raw_tx(&tx.txid()).unwrap();
+        assert!(res.is_none());
+    }
+
+    pub fn test_del_last_index<D: Database>(mut db: D) {
+        let keychain = KeychainKind::External;
+
+        let _res = db.increment_last_index(keychain);
+
+        let res = db.get_last_index(keychain).unwrap().unwrap();
+
+        assert_eq!(res, 0);
+
+        let _res = db.increment_last_index(keychain);
+
+        let res = db.del_last_index(keychain).unwrap().unwrap();
+
+        assert_eq!(res, 1);
+
+        let res = db.get_last_index(keychain).unwrap();
+        assert!(res.is_none());
+    }
+
+    pub fn test_check_descriptor_checksum<D: Database>(mut db: D) {
+        // insert checksum associated to keychain
+        let checksum = "1cead456".as_bytes();
+        let keychain = KeychainKind::External;
+        let _res = db.check_descriptor_checksum(keychain, checksum);
+
+        // check if `check_descriptor_checksum` throws
+        // `Error::ChecksumMismatch` error if the
+        // function is passed a checksum that does
+        // not match the one initially inserted
+        let checksum = "1cead454".as_bytes();
+        let keychain = KeychainKind::External;
+        let res = db.check_descriptor_checksum(keychain, checksum);
+
+        assert!(res.is_err());
     }
 
     // TODO: more tests...

src/database/sqlite.rs

@@ -52,7 +52,22 @@ static MIGRATIONS: &[&str] = &[
     "DELETE FROM transactions;",
     "DELETE FROM utxos;",
     "DROP INDEX idx_txid_vout;",
-    "CREATE UNIQUE INDEX idx_utxos_txid_vout ON utxos(txid, vout);"
+    "CREATE UNIQUE INDEX idx_utxos_txid_vout ON utxos(txid, vout);",
+    "ALTER TABLE utxos RENAME TO utxos_old;",
+    "CREATE TABLE utxos (value INTEGER, keychain TEXT, vout INTEGER, txid BLOB, script BLOB, is_spent BOOLEAN DEFAULT 0);",
+    "INSERT INTO utxos SELECT value, keychain, vout, txid, script, is_spent FROM utxos_old;",
+    "DROP TABLE utxos_old;",
+    "CREATE UNIQUE INDEX idx_utxos_txid_vout ON utxos(txid, vout);",
+    // Fix issue https://github.com/bitcoindevkit/bdk/issues/801: drop duplicated script_pubkeys
+    "ALTER TABLE script_pubkeys RENAME TO script_pubkeys_old;",
+    "DROP INDEX idx_keychain_child;",
+    "DROP INDEX idx_script;",
+    "CREATE TABLE script_pubkeys (keychain TEXT, child INTEGER, script BLOB);",
+    "CREATE INDEX idx_keychain_child ON script_pubkeys(keychain, child);",
+    "CREATE INDEX idx_script ON script_pubkeys(script);",
+    "CREATE UNIQUE INDEX idx_script_pks_unique ON script_pubkeys(keychain, child);",
+    "INSERT OR REPLACE INTO script_pubkeys SELECT keychain, child, script FROM script_pubkeys_old;",
+    "DROP TABLE script_pubkeys_old;"
 ];
 
 /// Sqlite database stored on filesystem
@@ -83,7 +98,7 @@ impl SqliteDatabase {
         child: u32,
         script: &[u8],
     ) -> Result<i64, Error> {
-        let mut statement = self.connection.prepare_cached("INSERT INTO script_pubkeys (keychain, child, script) VALUES (:keychain, :child, :script)")?;
+        let mut statement = self.connection.prepare_cached("INSERT OR REPLACE INTO script_pubkeys (keychain, child, script) VALUES (:keychain, :child, :script)")?;
         statement.execute(named_params! {
             ":keychain": keychain,
             ":child": child,
@@ -744,11 +759,13 @@ impl BatchOperations for SqliteDatabase {
         include_raw: bool,
     ) -> Result<Option<TransactionDetails>, Error> {
         match self.select_transaction_details_by_txid(txid)? {
-            Some(transaction_details) => {
+            Some(mut transaction_details) => {
                 self.delete_transaction_details_by_txid(txid)?;
 
                 if include_raw {
                     self.delete_transaction_by_txid(txid)?;
+                } else {
+                    transaction_details.transaction = None;
                 }
                 Ok(Some(transaction_details))
             }
@@ -914,8 +931,8 @@ impl BatchDatabase for SqliteDatabase {
 }
 
 pub fn get_connection<T: AsRef<Path>>(path: &T) -> Result<Connection, Error> {
-    let connection = Connection::open(path)?;
-    migrate(&connection)?;
+    let mut connection = Connection::open(path)?;
+    migrate(&mut connection)?;
     Ok(connection)
 }
 
@@ -950,28 +967,41 @@ pub fn set_schema_version(conn: &Connection, version: i32) -> rusqlite::Result<u
     )
 }
 
-pub fn migrate(conn: &Connection) -> rusqlite::Result<()> {
+pub fn migrate(conn: &mut Connection) -> Result<(), Error> {
     let version = get_schema_version(conn)?;
     let stmts = &MIGRATIONS[(version as usize)..];
-    let mut i: i32 = version;
 
-    if version == MIGRATIONS.len() as i32 {
+    // begin transaction, all migration statements and new schema version commit or rollback
+    let tx = conn.transaction()?;
+
+    // execute every statement and return `Some` new schema version
+    // if execution fails, return `Error::Rusqlite`
+    // if no statements executed returns `None`
+    let new_version = stmts
+        .iter()
+        .enumerate()
+        .map(|version_stmt| {
+            log::info!(
+                "executing db migration {}: `{}`",
+                version + version_stmt.0 as i32 + 1,
+                version_stmt.1
+            );
+            tx.execute(version_stmt.1, [])
+                // map result value to next migration version
+                .map(|_| version_stmt.0 as i32 + version + 1)
+        })
+        .last()
+        .transpose()?;
+
+    // if `Some` new statement version, set new schema version
+    if let Some(version) = new_version {
+        set_schema_version(&tx, version)?;
+    } else {
         log::info!("db up to date, no migration needed");
-        return Ok(());
     }
 
-    for stmt in stmts {
-        let res = conn.execute(stmt, []);
-        if res.is_err() {
-            println!("migration failed on:\n{}\n{:?}", stmt, res);
-            break;
-        }
-
-        i += 1;
-    }
-
-    set_schema_version(conn, i)?;
-
+    // commit transaction
+    tx.commit()?;
     Ok(())
 }
 
@@ -1036,4 +1066,84 @@ pub mod test {
     fn test_txs() {
         crate::database::test::test_list_transaction(get_database());
     }
+
+    #[test]
+    fn test_iter_raw_txs() {
+        crate::database::test::test_iter_raw_txs(get_database());
+    }
+
+    #[test]
+    fn test_del_path_from_script_pubkey() {
+        crate::database::test::test_del_path_from_script_pubkey(get_database());
+    }
+
+    #[test]
+    fn test_iter_script_pubkeys() {
+        crate::database::test::test_iter_script_pubkeys(get_database());
+    }
+
+    #[test]
+    fn test_del_utxo() {
+        crate::database::test::test_del_utxo(get_database());
+    }
+
+    #[test]
+    fn test_del_raw_tx() {
+        crate::database::test::test_del_raw_tx(get_database());
+    }
+
+    #[test]
+    fn test_del_tx() {
+        crate::database::test::test_del_tx(get_database());
+    }
+
+    #[test]
+    fn test_del_last_index() {
+        crate::database::test::test_del_last_index(get_database());
+    }
+
+    #[test]
+    fn test_check_descriptor_checksum() {
+        crate::database::test::test_check_descriptor_checksum(get_database());
+    }
+
+    // Issue 801: https://github.com/bitcoindevkit/bdk/issues/801
+    #[test]
+    fn test_unique_spks() {
+        use crate::bitcoin::hashes::hex::FromHex;
+        use crate::database::*;
+
+        let mut db = get_database();
+
+        let script = Script::from(
+            Vec::<u8>::from_hex("76a91402306a7c23f3e8010de41e9e591348bb83f11daa88ac").unwrap(),
+        );
+        let path = 42;
+        let keychain = KeychainKind::External;
+
+        for _ in 0..100 {
+            db.set_script_pubkey(&script, keychain, path).unwrap();
+        }
+
+        let mut statement = db
+            .connection
+            .prepare_cached(
+                "select keychain,child,count(child) from script_pubkeys group by keychain,child;",
+            )
+            .unwrap();
+        let mut rows = statement.query([]).unwrap();
+        while let Some(row) = rows.next().unwrap() {
+            let keychain: String = row.get(0).unwrap();
+            let child: u32 = row.get(1).unwrap();
+            let count: usize = row.get(2).unwrap();
+
+            assert!(
+                count == 1,
+                "keychain={}, child={}, count={}",
+                keychain,
+                child,
+                count
+            );
+        }
+    }
 }

src/descriptor/checksum.rs

@@ -41,12 +41,24 @@ fn poly_mod(mut c: u64, val: u64) -> u64 {
     c
 }
 
-/// Computes the checksum bytes of a descriptor
-pub fn get_checksum_bytes(desc: &str) -> Result<[u8; 8], DescriptorError> {
+/// Computes the checksum bytes of a descriptor.
+/// `exclude_hash = true` ignores all data after the first '#' (inclusive).
+pub(crate) fn calc_checksum_bytes_internal(
+    mut desc: &str,
+    exclude_hash: bool,
+) -> Result<[u8; 8], DescriptorError> {
     let mut c = 1;
     let mut cls = 0;
     let mut clscount = 0;
 
+    let mut original_checksum = None;
+    if exclude_hash {
+        if let Some(split) = desc.split_once('#') {
+            desc = split.0;
+            original_checksum = Some(split.1);
+        }
+    }
+
     for ch in desc.as_bytes() {
         let pos = INPUT_CHARSET
             .iter()
@@ -72,37 +84,96 @@ pub fn get_checksum_bytes(desc: &str) -> Result<[u8; 8], DescriptorError> {
         checksum[j] = CHECKSUM_CHARSET[((c >> (5 * (7 - j))) & 31) as usize];
     }
 
+    // if input data already had a checksum, check calculated checksum against original checksum
+    if let Some(original_checksum) = original_checksum {
+        if original_checksum.as_bytes() != checksum {
+            return Err(DescriptorError::InvalidDescriptorChecksum);
+        }
+    }
+
     Ok(checksum)
 }
 
+/// Compute the checksum bytes of a descriptor, excludes any existing checksum in the descriptor string from the calculation
+pub fn calc_checksum_bytes(desc: &str) -> Result<[u8; 8], DescriptorError> {
+    calc_checksum_bytes_internal(desc, true)
+}
+
+/// Compute the checksum of a descriptor, excludes any existing checksum in the descriptor string from the calculation
+pub fn calc_checksum(desc: &str) -> Result<String, DescriptorError> {
+    // unsafe is okay here as the checksum only uses bytes in `CHECKSUM_CHARSET`
+    calc_checksum_bytes_internal(desc, true)
+        .map(|b| unsafe { String::from_utf8_unchecked(b.to_vec()) })
+}
+
+// TODO in release 0.25.0, remove get_checksum_bytes and get_checksum
+// TODO in release 0.25.0, consolidate calc_checksum_bytes_internal into calc_checksum_bytes
+
+/// Compute the checksum bytes of a descriptor
+#[deprecated(
+    since = "0.24.0",
+    note = "Use new `calc_checksum_bytes` function which excludes any existing checksum in the descriptor string before calculating the checksum hash bytes. See https://github.com/bitcoindevkit/bdk/pull/765."
+)]
+pub fn get_checksum_bytes(desc: &str) -> Result<[u8; 8], DescriptorError> {
+    calc_checksum_bytes_internal(desc, false)
+}
+
 /// Compute the checksum of a descriptor
+#[deprecated(
+    since = "0.24.0",
+    note = "Use new `calc_checksum` function which excludes any existing checksum in the descriptor string before calculating the checksum hash. See https://github.com/bitcoindevkit/bdk/pull/765."
+)]
 pub fn get_checksum(desc: &str) -> Result<String, DescriptorError> {
     // unsafe is okay here as the checksum only uses bytes in `CHECKSUM_CHARSET`
-    get_checksum_bytes(desc).map(|b| unsafe { String::from_utf8_unchecked(b.to_vec()) })
+    calc_checksum_bytes_internal(desc, false)
+        .map(|b| unsafe { String::from_utf8_unchecked(b.to_vec()) })
 }
 
 #[cfg(test)]
 mod test {
     use super::*;
-    use crate::descriptor::get_checksum;
+    use crate::descriptor::calc_checksum;
 
-    // test get_checksum() function; it should return the same value as Bitcoin Core
+    // test calc_checksum() function; it should return the same value as Bitcoin Core
     #[test]
-    fn test_get_checksum() {
+    fn test_calc_checksum() {
         let desc = "wpkh(tprv8ZgxMBicQKsPdpkqS7Eair4YxjcuuvDPNYmKX3sCniCf16tHEVrjjiSXEkFRnUH77yXc6ZcwHHcLNfjdi5qUvw3VDfgYiH5mNsj5izuiu2N/1/2/*)";
-        assert_eq!(get_checksum(desc).unwrap(), "tqz0nc62");
+        assert_eq!(calc_checksum(desc).unwrap(), "tqz0nc62");
 
         let desc = "pkh(tpubD6NzVbkrYhZ4XHndKkuB8FifXm8r5FQHwrN6oZuWCz13qb93rtgKvD4PQsqC4HP4yhV3tA2fqr2RbY5mNXfM7RxXUoeABoDtsFUq2zJq6YK/44'/1'/0'/0/*)";
-        assert_eq!(get_checksum(desc).unwrap(), "lasegmfs");
+        assert_eq!(calc_checksum(desc).unwrap(), "lasegmfs");
+    }
+
+    // test calc_checksum() function; it should return the same value as Bitcoin Core even if the
+    // descriptor string includes a checksum hash
+    #[test]
+    fn test_calc_checksum_with_checksum_hash() {
+        let desc = "wpkh(tprv8ZgxMBicQKsPdpkqS7Eair4YxjcuuvDPNYmKX3sCniCf16tHEVrjjiSXEkFRnUH77yXc6ZcwHHcLNfjdi5qUvw3VDfgYiH5mNsj5izuiu2N/1/2/*)#tqz0nc62";
+        assert_eq!(calc_checksum(desc).unwrap(), "tqz0nc62");
+
+        let desc = "pkh(tpubD6NzVbkrYhZ4XHndKkuB8FifXm8r5FQHwrN6oZuWCz13qb93rtgKvD4PQsqC4HP4yhV3tA2fqr2RbY5mNXfM7RxXUoeABoDtsFUq2zJq6YK/44'/1'/0'/0/*)#lasegmfs";
+        assert_eq!(calc_checksum(desc).unwrap(), "lasegmfs");
+
+        let desc = "wpkh(tprv8ZgxMBicQKsPdpkqS7Eair4YxjcuuvDPNYmKX3sCniCf16tHEVrjjiSXEkFRnUH77yXc6ZcwHHcLNfjdi5qUvw3VDfgYiH5mNsj5izuiu2N/1/2/*)#tqz0nc26";
+        assert!(matches!(
+            calc_checksum(desc).err(),
+            Some(DescriptorError::InvalidDescriptorChecksum)
+        ));
+
+        let desc = "pkh(tpubD6NzVbkrYhZ4XHndKkuB8FifXm8r5FQHwrN6oZuWCz13qb93rtgKvD4PQsqC4HP4yhV3tA2fqr2RbY5mNXfM7RxXUoeABoDtsFUq2zJq6YK/44'/1'/0'/0/*)#lasegmsf";
+        assert!(matches!(
+            calc_checksum(desc).err(),
+            Some(DescriptorError::InvalidDescriptorChecksum)
+        ));
     }
 
     #[test]
-    fn test_get_checksum_invalid_character() {
+    fn test_calc_checksum_invalid_character() {
         let sparkle_heart = unsafe { std::str::from_utf8_unchecked(&[240, 159, 146, 150]) };
         let invalid_desc = format!("wpkh(tprv8ZgxMBicQKsPdpkqS7Eair4YxjcuuvDPNYmKX3sCniCf16tHEVrjjiSXEkFRnUH77yXc6ZcwHHcL{}fjdi5qUvw3VDfgYiH5mNsj5izuiu2N/1/2/*)", sparkle_heart);
 
         assert!(matches!(
-            get_checksum(&invalid_desc).err(),
+            calc_checksum(&invalid_desc).err(),
             Some(DescriptorError::InvalidDescriptorCharacter(invalid_char)) if invalid_char == sparkle_heart.as_bytes()[0]
         ));
     }

src/descriptor/derived.rs

@@ -1,210 +0,0 @@
-// Bitcoin Dev Kit
-// Written in 2020 by Alekos Filini <alekos.filini@gmail.com>
-//
-// Copyright (c) 2020-2021 Bitcoin Dev Kit Developers
-//
-// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
-// or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
-// You may not use this file except in accordance with one or both of these
-// licenses.
-
-//! Derived descriptor keys
-//!
-//! The [`DerivedDescriptorKey`] type is a wrapper over the standard [`DescriptorPublicKey`] which
-//! guarantees that all the extended keys have a fixed derivation path, i.e. all the wildcards have
-//! been replaced by actual derivation indexes.
-//!
-//! The [`AsDerived`] trait provides a quick way to derive descriptors to obtain a
-//! `Descriptor<DerivedDescriptorKey>` type. This, in turn, can be used to derive public
-//! keys for arbitrary derivation indexes.
-//!
-//! Combining this with [`Wallet::get_signers`], secret keys can also be derived.
-//!
-//! # Example
-//!
-//! ```
-//! # use std::str::FromStr;
-//! # use bitcoin::secp256k1::Secp256k1;
-//! use bdk::descriptor::{AsDerived, DescriptorPublicKey};
-//! use bdk::miniscript::{ToPublicKey, TranslatePk, MiniscriptKey};
-//!
-//! let secp = Secp256k1::gen_new();
-//!
-//! let key = DescriptorPublicKey::from_str("[aa600a45/84'/0'/0']tpubDCbDXFKoLTQp44wQuC12JgSn5g9CWGjZdpBHeTqyypZ4VvgYjTJmK9CkyR5bFvG9f4PutvwmvpYCLkFx2rpx25hiMs4sUgxJveW8ZzSAVAc/0/*")?;
-//! let (descriptor, _, _) = bdk::descriptor!(wpkh(key))?;
-//!
-//! // derived: wpkh([aa600a45/84'/0'/0']tpubDCbDXFKoLTQp44wQuC12JgSn5g9CWGjZdpBHeTqyypZ4VvgYjTJmK9CkyR5bFvG9f4PutvwmvpYCLkFx2rpx25hiMs4sUgxJveW8ZzSAVAc/0/42)#3ladd0t2
-//! let derived = descriptor.as_derived(42, &secp);
-//! println!("derived: {}", derived);
-//!
-//! // with_pks: wpkh(02373ecb54c5e83bd7e0d40adf78b65efaf12fafb13571f0261fc90364eee22e1e)#p4jjgvll
-//! let with_pks = derived.translate_pk_infallible(|pk| pk.to_public_key(), |pkh| pkh.to_public_key().to_pubkeyhash());
-//! println!("with_pks: {}", with_pks);
-//! # Ok::<(), Box<dyn std::error::Error>>(())
-//! ```
-//!
-//! [`Wallet::get_signers`]: crate::wallet::Wallet::get_signers
-
-use std::cmp::Ordering;
-use std::fmt;
-use std::hash::{Hash, Hasher};
-use std::ops::Deref;
-
-use bitcoin::hashes::hash160;
-use bitcoin::{PublicKey, XOnlyPublicKey};
-
-use miniscript::descriptor::{DescriptorSinglePub, SinglePubKey, Wildcard};
-use miniscript::{Descriptor, DescriptorPublicKey, MiniscriptKey, ToPublicKey, TranslatePk};
-
-use crate::wallet::utils::SecpCtx;
-
-/// Extended [`DescriptorPublicKey`] that has been derived
-///
-/// Derived keys are guaranteed to never contain wildcards of any kind
-#[derive(Debug, Clone)]
-pub struct DerivedDescriptorKey<'s>(DescriptorPublicKey, &'s SecpCtx);
-
-impl<'s> DerivedDescriptorKey<'s> {
-    /// Construct a new derived key
-    ///
-    /// Panics if the key is wildcard
-    pub fn new(key: DescriptorPublicKey, secp: &'s SecpCtx) -> DerivedDescriptorKey<'s> {
-        if let DescriptorPublicKey::XPub(xpub) = &key {
-            assert!(xpub.wildcard == Wildcard::None)
-        }
-
-        DerivedDescriptorKey(key, secp)
-    }
-}
-
-impl<'s> Deref for DerivedDescriptorKey<'s> {
-    type Target = DescriptorPublicKey;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl<'s> PartialEq for DerivedDescriptorKey<'s> {
-    fn eq(&self, other: &Self) -> bool {
-        self.0 == other.0
-    }
-}
-
-impl<'s> Eq for DerivedDescriptorKey<'s> {}
-
-impl<'s> PartialOrd for DerivedDescriptorKey<'s> {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        self.0.partial_cmp(&other.0)
-    }
-}
-
-impl<'s> Ord for DerivedDescriptorKey<'s> {
-    fn cmp(&self, other: &Self) -> Ordering {
-        self.0.cmp(&other.0)
-    }
-}
-
-impl<'s> fmt::Display for DerivedDescriptorKey<'s> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.0.fmt(f)
-    }
-}
-
-impl<'s> Hash for DerivedDescriptorKey<'s> {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.0.hash(state);
-    }
-}
-
-impl<'s> MiniscriptKey for DerivedDescriptorKey<'s> {
-    type Hash = Self;
-
-    fn to_pubkeyhash(&self) -> Self::Hash {
-        DerivedDescriptorKey(self.0.to_pubkeyhash(), self.1)
-    }
-
-    fn is_uncompressed(&self) -> bool {
-        self.0.is_uncompressed()
-    }
-}
-
-impl<'s> ToPublicKey for DerivedDescriptorKey<'s> {
-    fn to_public_key(&self) -> PublicKey {
-        match &self.0 {
-            DescriptorPublicKey::SinglePub(DescriptorSinglePub {
-                key: SinglePubKey::XOnly(_),
-                ..
-            }) => panic!("Found x-only public key in non-tr descriptor"),
-            DescriptorPublicKey::SinglePub(DescriptorSinglePub {
-                key: SinglePubKey::FullKey(ref pk),
-                ..
-            }) => *pk,
-            DescriptorPublicKey::XPub(ref xpub) => PublicKey::new(
-                xpub.xkey
-                    .derive_pub(self.1, &xpub.derivation_path)
-                    .expect("Shouldn't fail, only normal derivations")
-                    .public_key,
-            ),
-        }
-    }
-
-    fn to_x_only_pubkey(&self) -> XOnlyPublicKey {
-        match &self.0 {
-            DescriptorPublicKey::SinglePub(DescriptorSinglePub {
-                key: SinglePubKey::XOnly(ref pk),
-                ..
-            }) => *pk,
-            DescriptorPublicKey::SinglePub(DescriptorSinglePub {
-                key: SinglePubKey::FullKey(ref pk),
-                ..
-            }) => XOnlyPublicKey::from(pk.inner),
-            DescriptorPublicKey::XPub(ref xpub) => XOnlyPublicKey::from(
-                xpub.xkey
-                    .derive_pub(self.1, &xpub.derivation_path)
-                    .expect("Shouldn't fail, only normal derivations")
-                    .public_key,
-            ),
-        }
-    }
-
-    fn hash_to_hash160(hash: &Self::Hash) -> hash160::Hash {
-        hash.to_public_key().to_pubkeyhash()
-    }
-}
-
-/// Utilities to derive descriptors
-///
-/// Check out the [module level] documentation for more.
-///
-/// [module level]: crate::descriptor::derived
-pub trait AsDerived {
-    /// Derive a descriptor and transform all of its keys to `DerivedDescriptorKey`
-    fn as_derived<'s>(&self, index: u32, secp: &'s SecpCtx)
-        -> Descriptor<DerivedDescriptorKey<'s>>;
-
-    /// Transform the keys into `DerivedDescriptorKey`.
-    ///
-    /// Panics if the descriptor is not "fixed", i.e. if it's derivable
-    fn as_derived_fixed<'s>(&self, secp: &'s SecpCtx) -> Descriptor<DerivedDescriptorKey<'s>>;
-}
-
-impl AsDerived for Descriptor<DescriptorPublicKey> {
-    fn as_derived<'s>(
-        &self,
-        index: u32,
-        secp: &'s SecpCtx,
-    ) -> Descriptor<DerivedDescriptorKey<'s>> {
-        self.derive(index).translate_pk_infallible(
-            |key| DerivedDescriptorKey::new(key.clone(), secp),
-            |key| DerivedDescriptorKey::new(key.clone(), secp),
-        )
-    }
-
-    fn as_derived_fixed<'s>(&self, secp: &'s SecpCtx) -> Descriptor<DerivedDescriptorKey<'s>> {
-        assert!(!self.is_deriveable());
-
-        self.as_derived(0, secp)
-    }
-}

src/descriptor/dsl.rs

@@ -700,10 +700,10 @@ macro_rules! fragment {
         $crate::keys::make_pkh($key, &secp)
     });
     ( after ( $value:expr ) ) => ({
-        $crate::impl_leaf_opcode_value!(After, $value)
+        $crate::impl_leaf_opcode_value!(After, $crate::bitcoin::PackedLockTime($value)) // TODO!! https://github.com/rust-bitcoin/rust-bitcoin/issues/1302
     });
     ( older ( $value:expr ) ) => ({
-        $crate::impl_leaf_opcode_value!(Older, $value)
+        $crate::impl_leaf_opcode_value!(Older, $crate::bitcoin::Sequence($value)) // TODO!!
     });
     ( sha256 ( $hash:expr ) ) => ({
         $crate::impl_leaf_opcode_value!(Sha256, $hash)
@@ -795,7 +795,7 @@ macro_rules! fragment {
 mod test {
     use bitcoin::hashes::hex::ToHex;
     use bitcoin::secp256k1::Secp256k1;
-    use miniscript::descriptor::{DescriptorPublicKey, DescriptorTrait, KeyMap};
+    use miniscript::descriptor::{DescriptorPublicKey, KeyMap};
     use miniscript::{Descriptor, Legacy, Segwitv0};
 
     use std::str::FromStr;
@@ -806,8 +806,6 @@ mod test {
     use bitcoin::util::bip32;
     use bitcoin::PrivateKey;
 
-    use crate::descriptor::derived::AsDerived;
-
     // test the descriptor!() macro
 
     // verify descriptor generates expected script(s) (if bare or pk) or address(es)
@@ -817,17 +815,15 @@ mod test {
         is_fixed: bool,
         expected: &[&str],
     ) {
-        let secp = Secp256k1::new();
-
         let (desc, _key_map, _networks) = desc.unwrap();
         assert_eq!(desc.is_witness(), is_witness);
-        assert_eq!(!desc.is_deriveable(), is_fixed);
+        assert_eq!(!desc.has_wildcard(), is_fixed);
         for i in 0..expected.len() {
             let index = i as u32;
-            let child_desc = if !desc.is_deriveable() {
-                desc.as_derived_fixed(&secp)
+            let child_desc = if !desc.has_wildcard() {
+                desc.at_derivation_index(0)
             } else {
-                desc.as_derived(index, &secp)
+                desc.at_derivation_index(index)
             };
             let address = child_desc.address(Regtest);
             if let Ok(address) = address {

src/descriptor/error.rs

@@ -20,8 +20,6 @@ pub enum Error {
     InvalidDescriptorChecksum,
     /// The descriptor contains hardened derivation steps on public extended keys
     HardenedDerivationXpub,
-    /// The descriptor contains multiple keys with the same BIP32 fingerprint
-    DuplicatedKeys,
 
     /// Error thrown while working with [`keys`](crate::keys)
     Key(crate::keys::KeyError),

src/descriptor/mod.rs

@@ -14,33 +14,33 @@
 //! This module contains generic utilities to work with descriptors, plus some re-exported types
 //! from [`miniscript`].
 
-use std::collections::{BTreeMap, HashSet};
-use std::ops::Deref;
+use std::collections::BTreeMap;
 
 use bitcoin::util::bip32::{ChildNumber, DerivationPath, ExtendedPubKey, Fingerprint, KeySource};
 use bitcoin::util::{psbt, taproot};
 use bitcoin::{secp256k1, PublicKey, XOnlyPublicKey};
-use bitcoin::{Network, Script, TxOut};
+use bitcoin::{Network, TxOut};
 
-use miniscript::descriptor::{DescriptorType, InnerXKey, SinglePubKey};
+use miniscript::descriptor::{
+    DefiniteDescriptorKey, DescriptorSecretKey, DescriptorType, InnerXKey, SinglePubKey,
+};
 pub use miniscript::{
     descriptor::DescriptorXKey, descriptor::KeyMap, descriptor::Wildcard, Descriptor,
     DescriptorPublicKey, Legacy, Miniscript, ScriptContext, Segwitv0,
 };
-use miniscript::{DescriptorTrait, ForEachKey, TranslatePk};
+use miniscript::{ForEachKey, MiniscriptKey, TranslatePk};
 
 use crate::descriptor::policy::BuildSatisfaction;
 
 pub mod checksum;
-pub mod derived;
 #[doc(hidden)]
 pub mod dsl;
 pub mod error;
 pub mod policy;
 pub mod template;
 
-pub use self::checksum::get_checksum;
-pub use self::derived::{AsDerived, DerivedDescriptorKey};
+pub use self::checksum::calc_checksum;
+use self::checksum::calc_checksum_bytes;
 pub use self::error::Error as DescriptorError;
 pub use self::policy::Policy;
 use self::template::DescriptorTemplateOut;
@@ -52,7 +52,7 @@ use crate::wallet::utils::SecpCtx;
 pub type ExtendedDescriptor = Descriptor<DescriptorPublicKey>;
 
 /// Alias for a [`Descriptor`] that contains extended **derived** keys
-pub type DerivedDescriptor<'s> = Descriptor<DerivedDescriptorKey<'s>>;
+pub type DerivedDescriptor = Descriptor<DefiniteDescriptorKey>;
 
 /// Alias for the type of maps that represent derivation paths in a [`psbt::Input`] or
 /// [`psbt::Output`]
@@ -84,19 +84,15 @@ impl IntoWalletDescriptor for &str {
         secp: &SecpCtx,
         network: Network,
     ) -> Result<(ExtendedDescriptor, KeyMap), DescriptorError> {
-        let descriptor = if self.contains('#') {
-            let parts: Vec<&str> = self.splitn(2, '#').collect();
-            if !get_checksum(parts[0])
-                .ok()
-                .map(|computed| computed == parts[1])
-                .unwrap_or(false)
-            {
-                return Err(DescriptorError::InvalidDescriptorChecksum);
+        let descriptor = match self.split_once('#') {
+            Some((desc, original_checksum)) => {
+                let checksum = calc_checksum_bytes(desc)?;
+                if original_checksum.as_bytes() != checksum {
+                    return Err(DescriptorError::InvalidDescriptorChecksum);
+                }
+                desc
             }
-
-            parts[0]
-        } else {
-            self
+            None => self,
         };
 
         ExtendedDescriptor::parse_descriptor(secp, descriptor)?
@@ -132,28 +128,76 @@ impl IntoWalletDescriptor for (ExtendedDescriptor, KeyMap) {
     ) -> Result<(ExtendedDescriptor, KeyMap), DescriptorError> {
         use crate::keys::DescriptorKey;
 
-        let check_key = |pk: &DescriptorPublicKey| {
-            let (pk, _, networks) = if self.0.is_witness() {
-                let descriptor_key: DescriptorKey<miniscript::Segwitv0> =
-                    pk.clone().into_descriptor_key()?;
-                descriptor_key.extract(secp)?
-            } else {
-                let descriptor_key: DescriptorKey<miniscript::Legacy> =
-                    pk.clone().into_descriptor_key()?;
-                descriptor_key.extract(secp)?
-            };
+        struct Translator<'s, 'd> {
+            secp: &'s SecpCtx,
+            descriptor: &'d ExtendedDescriptor,
+            network: Network,
+        }
 
-            if networks.contains(&network) {
-                Ok(pk)
-            } else {
-                Err(DescriptorError::Key(KeyError::InvalidNetwork))
+        impl<'s, 'd>
+            miniscript::Translator<DescriptorPublicKey, miniscript::DummyKey, DescriptorError>
+            for Translator<'s, 'd>
+        {
+            fn pk(
+                &mut self,
+                pk: &DescriptorPublicKey,
+            ) -> Result<miniscript::DummyKey, DescriptorError> {
+                let secp = &self.secp;
+
+                let (_, _, networks) = if self.descriptor.is_taproot() {
+                    let descriptor_key: DescriptorKey<miniscript::Tap> =
+                        pk.clone().into_descriptor_key()?;
+                    descriptor_key.extract(secp)?
+                } else if self.descriptor.is_witness() {
+                    let descriptor_key: DescriptorKey<miniscript::Segwitv0> =
+                        pk.clone().into_descriptor_key()?;
+                    descriptor_key.extract(secp)?
+                } else {
+                    let descriptor_key: DescriptorKey<miniscript::Legacy> =
+                        pk.clone().into_descriptor_key()?;
+                    descriptor_key.extract(secp)?
+                };
+
+                if networks.contains(&self.network) {
+                    Ok(miniscript::DummyKey)
+                } else {
+                    Err(DescriptorError::Key(KeyError::InvalidNetwork))
+                }
             }
-        };
+            fn sha256(
+                &mut self,
+                _sha256: &<DescriptorPublicKey as MiniscriptKey>::Sha256,
+            ) -> Result<miniscript::DummySha256Hash, DescriptorError> {
+                Ok(Default::default())
+            }
+            fn hash256(
+                &mut self,
+                _hash256: &<DescriptorPublicKey as MiniscriptKey>::Hash256,
+            ) -> Result<miniscript::DummyHash256Hash, DescriptorError> {
+                Ok(Default::default())
+            }
+            fn ripemd160(
+                &mut self,
+                _ripemd160: &<DescriptorPublicKey as MiniscriptKey>::Ripemd160,
+            ) -> Result<miniscript::DummyRipemd160Hash, DescriptorError> {
+                Ok(Default::default())
+            }
+            fn hash160(
+                &mut self,
+                _hash160: &<DescriptorPublicKey as MiniscriptKey>::Hash160,
+            ) -> Result<miniscript::DummyHash160Hash, DescriptorError> {
+                Ok(Default::default())
+            }
+        }
 
         // check the network for the keys
-        let translated = self.0.translate_pk(check_key, check_key)?;
+        self.0.translate_pk(&mut Translator {
+            secp,
+            network,
+            descriptor: &self.0,
+        })?;
 
-        Ok((translated, self.1))
+        Ok(self)
     }
 }
 
@@ -163,10 +207,17 @@ impl IntoWalletDescriptor for DescriptorTemplateOut {
         _secp: &SecpCtx,
         network: Network,
     ) -> Result<(ExtendedDescriptor, KeyMap), DescriptorError> {
-        let valid_networks = &self.2;
+        struct Translator {
+            network: Network,
+        }
 
-        let fix_key = |pk: &DescriptorPublicKey| {
-            if valid_networks.contains(&network) {
+        impl miniscript::Translator<DescriptorPublicKey, DescriptorPublicKey, DescriptorError>
+            for Translator
+        {
+            fn pk(
+                &mut self,
+                pk: &DescriptorPublicKey,
+            ) -> Result<DescriptorPublicKey, DescriptorError> {
                 // workaround for xpubs generated by other key types, like bip39: since when the
                 // conversion is made one network has to be chosen, what we generally choose
                 // "mainnet", but then override the set of valid networks to specify that all of
@@ -175,7 +226,7 @@ impl IntoWalletDescriptor for DescriptorTemplateOut {
                 let pk = match pk {
                     DescriptorPublicKey::XPub(ref xpub) => {
                         let mut xpub = xpub.clone();
-                        xpub.xkey.network = network;
+                        xpub.xkey.network = self.network;
 
                         DescriptorPublicKey::XPub(xpub)
                     }
@@ -183,15 +234,42 @@ impl IntoWalletDescriptor for DescriptorTemplateOut {
                 };
 
                 Ok(pk)
-            } else {
-                Err(DescriptorError::Key(KeyError::InvalidNetwork))
             }
-        };
+            miniscript::translate_hash_clone!(
+                DescriptorPublicKey,
+                DescriptorPublicKey,
+                DescriptorError
+            );
+        }
 
-        // fixup the network for keys that need it
-        let translated = self.0.translate_pk(fix_key, fix_key)?;
+        let (desc, keymap, networks) = self;
 
-        Ok((translated, self.1))
+        if !networks.contains(&network) {
+            return Err(DescriptorError::Key(KeyError::InvalidNetwork));
+        }
+
+        // fixup the network for keys that need it in the descriptor
+        let translated = desc.translate_pk(&mut Translator { network })?;
+        // ...and in the key map
+        let fixed_keymap = keymap
+            .into_iter()
+            .map(|(mut k, mut v)| {
+                match (&mut k, &mut v) {
+                    (DescriptorPublicKey::XPub(xpub), DescriptorSecretKey::XPrv(xprv)) => {
+                        xpub.xkey.network = network;
+                        xprv.xkey.network = network;
+                    }
+                    (_, DescriptorSecretKey::Single(key)) => {
+                        key.key.network = network;
+                    }
+                    _ => {}
+                }
+
+                (k, v)
+            })
+            .collect();
+
+        Ok((translated, fixed_keymap))
     }
 }
 
@@ -210,7 +288,7 @@ pub(crate) fn into_wallet_descriptor_checked<T: IntoWalletDescriptor>(
             derivation_path,
             wildcard,
             ..
-        }) = k.as_key()
+        }) = k
         {
             return *wildcard == Wildcard::Hardened
                 || derivation_path.into_iter().any(ChildNumber::is_hardened);
@@ -222,23 +300,9 @@ pub(crate) fn into_wallet_descriptor_checked<T: IntoWalletDescriptor>(
         return Err(DescriptorError::HardenedDerivationXpub);
     }
 
-    // Ensure that there are no duplicated keys
-    let mut found_keys = HashSet::new();
-    let descriptor_contains_duplicated_keys = descriptor.for_any_key(|k| {
-        if let DescriptorPublicKey::XPub(xkey) = k.as_key() {
-            let fingerprint = xkey.root_fingerprint(secp);
-            if found_keys.contains(&fingerprint) {
-                return true;
-            }
-
-            found_keys.insert(fingerprint);
-        }
-
-        false
-    });
-    if descriptor_contains_duplicated_keys {
-        return Err(DescriptorError::DuplicatedKeys);
-    }
+    // Run miniscript's sanity check, which will look for duplicated keys and other potential
+    // issues
+    descriptor.sanity_check()?;
 
     Ok((descriptor, keymap))
 }
@@ -271,7 +335,6 @@ pub trait ExtractPolicy {
 }
 
 pub(crate) trait XKeyUtils {
-    fn full_path(&self, append: &[ChildNumber]) -> DerivationPath;
     fn root_fingerprint(&self, secp: &SecpCtx) -> Fingerprint;
 }
 
@@ -279,27 +342,6 @@ impl<T> XKeyUtils for DescriptorXKey<T>
 where
     T: InnerXKey,
 {
-    fn full_path(&self, append: &[ChildNumber]) -> DerivationPath {
-        let full_path = match self.origin {
-            Some((_, ref path)) => path
-                .into_iter()
-                .chain(self.derivation_path.into_iter())
-                .cloned()
-                .collect(),
-            None => self.derivation_path.clone(),
-        };
-
-        if self.wildcard != Wildcard::None {
-            full_path
-                .into_iter()
-                .chain(append.iter())
-                .cloned()
-                .collect()
-        } else {
-            full_path
-        }
-    }
-
     fn root_fingerprint(&self, secp: &SecpCtx) -> Fingerprint {
         match self.origin {
             Some((fingerprint, _)) => fingerprint,
@@ -308,11 +350,6 @@ where
     }
 }
 
-pub(crate) trait DerivedDescriptorMeta {
-    fn get_hd_keypaths(&self, secp: &SecpCtx) -> HdKeyPaths;
-    fn get_tap_key_origins(&self, secp: &SecpCtx) -> TapKeyOrigins;
-}
-
 pub(crate) trait DescriptorMeta {
     fn is_witness(&self) -> bool;
     fn is_taproot(&self) -> bool;
@@ -321,63 +358,23 @@ pub(crate) trait DescriptorMeta {
         &self,
         hd_keypaths: &HdKeyPaths,
         secp: &'s SecpCtx,
-    ) -> Option<DerivedDescriptor<'s>>;
+    ) -> Option<DerivedDescriptor>;
     fn derive_from_tap_key_origins<'s>(
         &self,
         tap_key_origins: &TapKeyOrigins,
         secp: &'s SecpCtx,
-    ) -> Option<DerivedDescriptor<'s>>;
+    ) -> Option<DerivedDescriptor>;
     fn derive_from_psbt_key_origins<'s>(
         &self,
         key_origins: BTreeMap<Fingerprint, (&DerivationPath, SinglePubKey)>,
         secp: &'s SecpCtx,
-    ) -> Option<DerivedDescriptor<'s>>;
+    ) -> Option<DerivedDescriptor>;
     fn derive_from_psbt_input<'s>(
         &self,
         psbt_input: &psbt::Input,
         utxo: Option<TxOut>,
         secp: &'s SecpCtx,
-    ) -> Option<DerivedDescriptor<'s>>;
-}
-
-pub(crate) trait DescriptorScripts {
-    fn psbt_redeem_script(&self) -> Option<Script>;
-    fn psbt_witness_script(&self) -> Option<Script>;
-}
-
-impl<'s> DescriptorScripts for DerivedDescriptor<'s> {
-    fn psbt_redeem_script(&self) -> Option<Script> {
-        match self.desc_type() {
-            DescriptorType::ShWpkh => Some(self.explicit_script().unwrap()),
-            DescriptorType::ShWsh => Some(self.explicit_script().unwrap().to_v0_p2wsh()),
-            DescriptorType::Sh => Some(self.explicit_script().unwrap()),
-            DescriptorType::Bare => Some(self.explicit_script().unwrap()),
-            DescriptorType::ShSortedMulti => Some(self.explicit_script().unwrap()),
-            DescriptorType::ShWshSortedMulti => Some(self.explicit_script().unwrap().to_v0_p2wsh()),
-            DescriptorType::Pkh
-            | DescriptorType::Wpkh
-            | DescriptorType::Tr
-            | DescriptorType::Wsh
-            | DescriptorType::WshSortedMulti => None,
-        }
-    }
-
-    fn psbt_witness_script(&self) -> Option<Script> {
-        match self.desc_type() {
-            DescriptorType::Wsh => Some(self.explicit_script().unwrap()),
-            DescriptorType::ShWsh => Some(self.explicit_script().unwrap()),
-            DescriptorType::WshSortedMulti | DescriptorType::ShWshSortedMulti => {
-                Some(self.explicit_script().unwrap())
-            }
-            DescriptorType::Bare
-            | DescriptorType::Sh
-            | DescriptorType::Pkh
-            | DescriptorType::Wpkh
-            | DescriptorType::ShSortedMulti
-            | DescriptorType::Tr
-            | DescriptorType::ShWpkh => None,
-        }
-    }
+    ) -> Option<DerivedDescriptor>;
 }
 
 impl DescriptorMeta for ExtendedDescriptor {
@@ -401,7 +398,7 @@ impl DescriptorMeta for ExtendedDescriptor {
         let mut answer = Vec::new();
 
         self.for_each_key(|pk| {
-            if let DescriptorPublicKey::XPub(xpub) = pk.as_key() {
+            if let DescriptorPublicKey::XPub(xpub) = pk {
                 answer.push(xpub.clone());
             }
 
@@ -415,7 +412,7 @@ impl DescriptorMeta for ExtendedDescriptor {
         &self,
         key_origins: BTreeMap<Fingerprint, (&DerivationPath, SinglePubKey)>,
         secp: &'s SecpCtx,
-    ) -> Option<DerivedDescriptor<'s>> {
+    ) -> Option<DerivedDescriptor> {
         // Ensure that deriving `xpub` with `path` yields `expected`
         let verify_key = |xpub: &DescriptorXKey<ExtendedPubKey>,
                           path: &DerivationPath,
@@ -437,7 +434,7 @@ impl DescriptorMeta for ExtendedDescriptor {
 
         // using `for_any_key` should make this stop as soon as we return `true`
         self.for_any_key(|key| {
-            if let DescriptorPublicKey::XPub(xpub) = key.as_key().deref() {
+            if let DescriptorPublicKey::XPub(xpub) = key {
                 // Check if the key matches one entry in our `key_origins`. If it does, `matches()` will
                 // return the "prefix" that matched, so we remove that prefix from the full path
                 // found in `key_origins` and save it in `derive_path`. We expect this to be a derivation
@@ -495,14 +492,14 @@ impl DescriptorMeta for ExtendedDescriptor {
             false
         });
 
-        path_found.map(|path| self.as_derived(path, secp))
+        path_found.map(|path| self.at_derivation_index(path))
     }
 
     fn derive_from_hd_keypaths<'s>(
         &self,
         hd_keypaths: &HdKeyPaths,
         secp: &'s SecpCtx,
-    ) -> Option<DerivedDescriptor<'s>> {
+    ) -> Option<DerivedDescriptor> {
         // "Convert" an hd_keypaths map to the format required by `derive_from_psbt_key_origins`
         let key_origins = hd_keypaths
             .iter()
@@ -520,7 +517,7 @@ impl DescriptorMeta for ExtendedDescriptor {
         &self,
         tap_key_origins: &TapKeyOrigins,
         secp: &'s SecpCtx,
-    ) -> Option<DerivedDescriptor<'s>> {
+    ) -> Option<DerivedDescriptor> {
         // "Convert" a tap_key_origins map to the format required by `derive_from_psbt_key_origins`
         let key_origins = tap_key_origins
             .iter()
@@ -534,19 +531,19 @@ impl DescriptorMeta for ExtendedDescriptor {
         psbt_input: &psbt::Input,
         utxo: Option<TxOut>,
         secp: &'s SecpCtx,
-    ) -> Option<DerivedDescriptor<'s>> {
+    ) -> Option<DerivedDescriptor> {
         if let Some(derived) = self.derive_from_hd_keypaths(&psbt_input.bip32_derivation, secp) {
             return Some(derived);
         }
         if let Some(derived) = self.derive_from_tap_key_origins(&psbt_input.tap_key_origins, secp) {
             return Some(derived);
         }
-        if self.is_deriveable() {
+        if self.has_wildcard() {
             // We can't try to bruteforce the derivation index, exit here
             return None;
         }
 
-        let descriptor = self.as_derived_fixed(secp);
+        let descriptor = self.at_derivation_index(0);
         match descriptor.desc_type() {
             // TODO: add pk() here
             DescriptorType::Pkh
@@ -580,86 +577,6 @@ impl DescriptorMeta for ExtendedDescriptor {
     }
 }
 
-impl<'s> DerivedDescriptorMeta for DerivedDescriptor<'s> {
-    fn get_hd_keypaths(&self, secp: &SecpCtx) -> HdKeyPaths {
-        let mut answer = BTreeMap::new();
-        self.for_each_key(|key| {
-            if let DescriptorPublicKey::XPub(xpub) = key.as_key().deref() {
-                let derived_pubkey = xpub
-                    .xkey
-                    .derive_pub(secp, &xpub.derivation_path)
-                    .expect("Derivation can't fail");
-
-                answer.insert(
-                    derived_pubkey.public_key,
-                    (xpub.root_fingerprint(secp), xpub.full_path(&[])),
-                );
-            }
-
-            true
-        });
-
-        answer
-    }
-
-    fn get_tap_key_origins(&self, secp: &SecpCtx) -> TapKeyOrigins {
-        use miniscript::ToPublicKey;
-
-        let mut answer = BTreeMap::new();
-        let mut insert_path = |pk: &DerivedDescriptorKey<'_>, lh| {
-            let key_origin = match pk.deref() {
-                DescriptorPublicKey::XPub(xpub) => {
-                    Some((xpub.root_fingerprint(secp), xpub.full_path(&[])))
-                }
-                DescriptorPublicKey::SinglePub(_) => None,
-            };
-
-            // If this is the internal key, we only insert the key origin if it's not None.
-            // For keys found in the tap tree we always insert a key origin (because the signer
-            // looks for it to know which leaves to sign for), even though it may be None
-            match (lh, key_origin) {
-                (None, Some(ko)) => {
-                    answer
-                        .entry(pk.to_x_only_pubkey())
-                        .or_insert_with(|| (vec![], ko));
-                }
-                (Some(lh), origin) => {
-                    answer
-                        .entry(pk.to_x_only_pubkey())
-                        .or_insert_with(|| (vec![], origin.unwrap_or_default()))
-                        .0
-                        .push(lh);
-                }
-                _ => {}
-            }
-        };
-
-        if let Descriptor::Tr(tr) = &self {
-            // Internal key first, then iterate the scripts
-            insert_path(tr.internal_key(), None);
-
-            for (_, ms) in tr.iter_scripts() {
-                // Assume always the same leaf version
-                let leaf_hash = taproot::TapLeafHash::from_script(
-                    &ms.encode(),
-                    taproot::LeafVersion::TapScript,
-                );
-
-                for key in ms.iter_pk_pkh() {
-                    let key = match key {
-                        miniscript::miniscript::iter::PkPkh::PlainPubkey(pk) => pk,
-                        miniscript::miniscript::iter::PkPkh::HashedPubkey(pk) => pk,
-                    };
-
-                    insert_path(&key, Some(leaf_hash));
-                }
-            }
-        }
-
-        answer
-    }
-}
-
 #[cfg(test)]
 mod test {
     use std::str::FromStr;
@@ -787,23 +704,40 @@ mod test {
 
         let secp = Secp256k1::new();
 
-        let xpub = bip32::ExtendedPubKey::from_str("xpub6ERApfZwUNrhLCkDtcHTcxd75RbzS1ed54G1LkBUHQVHQKqhMkhgbmJbZRkrgZw4koxb5JaHWkY4ALHY2grBGRjaDMzQLcgJvLJuZZvRcEL").unwrap();
+        let xprv = bip32::ExtendedPrivKey::from_str("xprv9s21ZrQH143K3c3gF1DUWpWNr2SG2XrG8oYPpqYh7hoWsJy9NjabErnzriJPpnGHyKz5NgdXmq1KVbqS1r4NXdCoKitWg5e86zqXHa8kxyB").unwrap();
         let path = bip32::DerivationPath::from_str("m/0").unwrap();
 
         // here `to_descriptor_key` will set the valid networks for the key to only mainnet, since
         // we are using an "xpub"
-        let key = (xpub, path).into_descriptor_key().unwrap();
+        let key = (xprv, path.clone()).into_descriptor_key().unwrap();
         // override it with any. this happens in some key conversions, like bip39
         let key = key.override_valid_networks(any_network());
 
         // make a descriptor out of it
         let desc = crate::descriptor!(wpkh(key)).unwrap();
         // this should convert the key that supports "any_network" to the right network (testnet)
-        let (wallet_desc, _) = desc
+        let (wallet_desc, keymap) = desc
             .into_wallet_descriptor(&secp, Network::Testnet)
             .unwrap();
 
-        assert_eq!(wallet_desc.to_string(), "wpkh(tpubDEnoLuPdBep9bzw5LoGYpsxUQYheRQ9gcgrJhJEcdKFB9cWQRyYmkCyRoTqeD4tJYiVVgt6A3rN6rWn9RYhR9sBsGxji29LYWHuKKbdb1ev/0/*)#y8p7e8kk");
+        let mut xprv_testnet = xprv;
+        xprv_testnet.network = Network::Testnet;
+
+        let xpub_testnet = bip32::ExtendedPubKey::from_priv(&secp, &xprv_testnet);
+        let desc_pubkey = DescriptorPublicKey::XPub(DescriptorXKey {
+            xkey: xpub_testnet,
+            origin: None,
+            derivation_path: path,
+            wildcard: Wildcard::Unhardened,
+        });
+
+        assert_eq!(wallet_desc.to_string(), "wpkh(tpubD6NzVbkrYhZ4XtJzoDja5snUjBNQRP5B3f4Hyn1T1x6PVPxzzVjvw6nJx2D8RBCxog9GEVjZoyStfepTz7TtKoBVdkCtnc7VCJh9dD4RAU9/0/*)#a3svx0ha");
+        assert_eq!(
+            keymap
+                .get(&desc_pubkey)
+                .map(|key| key.to_public(&secp).unwrap()),
+            Some(desc_pubkey)
+        );
     }
 
     // test IntoWalletDescriptor trait from &str with and without checksum appended
@@ -923,19 +857,15 @@ mod test {
             DescriptorError::HardenedDerivationXpub
         ));
 
-        let descriptor = "wsh(multi(2,tpubD6NzVbkrYhZ4XHndKkuB8FifXm8r5FQHwrN6oZuWCz13qb93rtgKvD4PQsqC4HP4yhV3tA2fqr2RbY5mNXfM7RxXUoeABoDtsFUq2zJq6YK/0/*,tpubD6NzVbkrYhZ4XHndKkuB8FifXm8r5FQHwrN6oZuWCz13qb93rtgKvD4PQsqC4HP4yhV3tA2fqr2RbY5mNXfM7RxXUoeABoDtsFUq2zJq6YK/1/*))";
+        let descriptor = "wsh(multi(2,tpubD6NzVbkrYhZ4XHndKkuB8FifXm8r5FQHwrN6oZuWCz13qb93rtgKvD4PQsqC4HP4yhV3tA2fqr2RbY5mNXfM7RxXUoeABoDtsFUq2zJq6YK/0/*,tpubD6NzVbkrYhZ4XHndKkuB8FifXm8r5FQHwrN6oZuWCz13qb93rtgKvD4PQsqC4HP4yhV3tA2fqr2RbY5mNXfM7RxXUoeABoDtsFUq2zJq6YK/0/*))";
         let result = into_wallet_descriptor_checked(descriptor, &secp, Network::Testnet);
 
         assert!(result.is_err());
-        assert!(matches!(
-            result.unwrap_err(),
-            DescriptorError::DuplicatedKeys
-        ));
     }
 
     #[test]
     fn test_sh_wsh_sortedmulti_redeemscript() {
-        use super::{AsDerived, DescriptorScripts};
+        use miniscript::psbt::PsbtInputExt;
 
         let secp = Secp256k1::new();
 
@@ -943,11 +873,16 @@ mod test {
         let (descriptor, _) =
             into_wallet_descriptor_checked(descriptor, &secp, Network::Testnet).unwrap();
 
-        let descriptor = descriptor.as_derived(0, &secp);
+        let descriptor = descriptor.at_derivation_index(0);
 
         let script = Script::from_str("5321022f533b667e2ea3b36e21961c9fe9dca340fbe0af5210173a83ae0337ab20a57621026bb53a98e810bd0ee61a0ed1164ba6c024786d76554e793e202dc6ce9c78c4ea2102d5b8a7d66a41ffdb6f4c53d61994022e886b4f45001fb158b95c9164d45f8ca3210324b75eead2c1f9c60e8adeb5e7009fec7a29afcdb30d829d82d09562fe8bae8521032d34f8932200833487bd294aa219dcbe000b9f9b3d824799541430009f0fa55121037468f8ea99b6c64788398b5ad25480cad08f4b0d65be54ce3a55fd206b5ae4722103f72d3d96663b0ea99b0aeb0d7f273cab11a8de37885f1dddc8d9112adb87169357ae").unwrap();
 
-        assert_eq!(descriptor.psbt_redeem_script(), Some(script.to_v0_p2wsh()));
-        assert_eq!(descriptor.psbt_witness_script(), Some(script));
+        let mut psbt_input = psbt::Input::default();
+        psbt_input
+            .update_with_descriptor_unchecked(&descriptor)
+            .unwrap();
+
+        assert_eq!(psbt_input.redeem_script, Some(script.to_v0_p2wsh()));
+        assert_eq!(psbt_input.witness_script, Some(script));
     }
 }

src/descriptor/policy.rs

@@ -43,14 +43,17 @@ use std::fmt;
 use serde::ser::SerializeMap;
 use serde::{Serialize, Serializer};
 
-use bitcoin::hashes::*;
+use bitcoin::hashes::{hash160, ripemd160, sha256};
 use bitcoin::util::bip32::Fingerprint;
-use bitcoin::{PublicKey, XOnlyPublicKey};
+use bitcoin::{LockTime, PublicKey, Sequence, XOnlyPublicKey};
 
 use miniscript::descriptor::{
-    DescriptorPublicKey, DescriptorSinglePub, ShInner, SinglePubKey, SortedMultiVec, WshInner,
+    DescriptorPublicKey, ShInner, SinglePub, SinglePubKey, SortedMultiVec, WshInner,
+};
+use miniscript::hash256;
+use miniscript::{
+    Descriptor, Miniscript, Satisfier, ScriptContext, SigType, Terminal, ToPublicKey,
 };
-use miniscript::{Descriptor, Miniscript, MiniscriptKey, Satisfier, ScriptContext, Terminal};
 
 #[allow(unused_imports)]
 use log::{debug, error, info, trace};
@@ -58,9 +61,9 @@ use log::{debug, error, info, trace};
 use crate::descriptor::ExtractPolicy;
 use crate::keys::ExtScriptContext;
 use crate::wallet::signer::{SignerId, SignersContainer};
-use crate::wallet::utils::{self, After, Older, SecpCtx};
+use crate::wallet::utils::{After, Older, SecpCtx};
 
-use super::checksum::get_checksum;
+use super::checksum::calc_checksum;
 use super::error::Error;
 use super::XKeyUtils;
 use bitcoin::util::psbt::{Input as PsbtInput, PartiallySignedTransaction as Psbt};
@@ -81,11 +84,11 @@ pub enum PkOrF {
 impl PkOrF {
     fn from_key(k: &DescriptorPublicKey, secp: &SecpCtx) -> Self {
         match k {
-            DescriptorPublicKey::SinglePub(DescriptorSinglePub {
+            DescriptorPublicKey::Single(SinglePub {
                 key: SinglePubKey::FullKey(pk),
                 ..
             }) => PkOrF::Pubkey(*pk),
-            DescriptorPublicKey::SinglePub(DescriptorSinglePub {
+            DescriptorPublicKey::Single(SinglePub {
                 key: SinglePubKey::XOnly(pk),
                 ..
             }) => PkOrF::XOnlyPubkey(*pk),
@@ -111,7 +114,7 @@ pub enum SatisfiableItem {
     /// Double SHA256 preimage hash
     Hash256Preimage {
         /// The digest value
-        hash: sha256d::Hash,
+        hash: hash256::Hash,
     },
     /// RIPEMD160 preimage hash
     Ripemd160Preimage {
@@ -125,13 +128,13 @@ pub enum SatisfiableItem {
     },
     /// Absolute timeclock timestamp
     AbsoluteTimelock {
-        /// The timestamp value
-        value: u32,
+        /// The timelock value
+        value: LockTime,
     },
     /// Relative timelock locktime
     RelativeTimelock {
-        /// The locktime value
-        value: u32,
+        /// The timelock value
+        value: Sequence,
     },
     /// Multi-signature public keys with threshold count
     Multisig {
@@ -165,7 +168,7 @@ impl SatisfiableItem {
 
     /// Returns a unique id for the [`SatisfiableItem`]
     pub fn id(&self) -> String {
-        get_checksum(&serde_json::to_string(self).expect("Failed to serialize a SatisfiableItem"))
+        calc_checksum(&serde_json::to_string(self).expect("Failed to serialize a SatisfiableItem"))
             .expect("Failed to compute a SatisfiableItem id")
     }
 }
@@ -438,32 +441,30 @@ pub struct Policy {
 }
 
 /// An extra condition that must be satisfied but that is out of control of the user
-#[derive(Hash, Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Default, Serialize)]
+/// TODO: use `bitcoin::LockTime` and `bitcoin::Sequence`
+#[derive(Hash, Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Default, Serialize)]
 pub struct Condition {
     /// Optional CheckSequenceVerify condition
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub csv: Option<u32>,
+    pub csv: Option<Sequence>,
     /// Optional timelock condition
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub timelock: Option<u32>,
+    pub timelock: Option<LockTime>,
 }
 
 impl Condition {
-    fn merge_nlocktime(a: u32, b: u32) -> Result<u32, PolicyError> {
-        if (a < utils::BLOCKS_TIMELOCK_THRESHOLD) != (b < utils::BLOCKS_TIMELOCK_THRESHOLD) {
+    fn merge_nlocktime(a: LockTime, b: LockTime) -> Result<LockTime, PolicyError> {
+        if !a.is_same_unit(b) {
             Err(PolicyError::MixedTimelockUnits)
+        } else if a > b {
+            Ok(a)
         } else {
-            Ok(max(a, b))
+            Ok(b)
         }
     }
 
-    fn merge_nsequence(a: u32, b: u32) -> Result<u32, PolicyError> {
-        let mask = utils::SEQUENCE_LOCKTIME_TYPE_FLAG | utils::SEQUENCE_LOCKTIME_MASK;
-
-        let a = a & mask;
-        let b = b & mask;
-
-        if (a < utils::SEQUENCE_LOCKTIME_TYPE_FLAG) != (b < utils::SEQUENCE_LOCKTIME_TYPE_FLAG) {
+    fn merge_nsequence(a: Sequence, b: Sequence) -> Result<Sequence, PolicyError> {
+        if a.is_time_locked() != b.is_time_locked() {
             Err(PolicyError::MixedTimelockUnits)
         } else {
             Ok(max(a, b))
@@ -720,15 +721,18 @@ impl From<SatisfiableItem> for Policy {
 }
 
 fn signer_id(key: &DescriptorPublicKey, secp: &SecpCtx) -> SignerId {
+    // For consistency we always compute the key hash in "ecdsa" form (with the leading sign
+    // prefix) even if we are in a taproot descriptor. We just want some kind of unique identifier
+    // for a key, so it doesn't really matter how the identifier is computed.
     match key {
-        DescriptorPublicKey::SinglePub(DescriptorSinglePub {
+        DescriptorPublicKey::Single(SinglePub {
             key: SinglePubKey::FullKey(pk),
             ..
-        }) => pk.to_pubkeyhash().into(),
-        DescriptorPublicKey::SinglePub(DescriptorSinglePub {
+        }) => pk.to_pubkeyhash(SigType::Ecdsa).into(),
+        DescriptorPublicKey::Single(SinglePub {
             key: SinglePubKey::XOnly(pk),
             ..
-        }) => pk.to_pubkeyhash().into(),
+        }) => pk.to_pubkeyhash(SigType::Ecdsa).into(),
         DescriptorPublicKey::XPub(xpub) => xpub.root_fingerprint(secp).into(),
     }
 }
@@ -779,7 +783,7 @@ fn generic_sig_in_psbt<
 ) -> bool {
     //TODO check signature validity
     psbt.inputs.iter().all(|input| match key {
-        DescriptorPublicKey::SinglePub(DescriptorSinglePub { key, .. }) => check(input, key),
+        DescriptorPublicKey::Single(SinglePub { key, .. }) => check(input, key),
         DescriptorPublicKey::XPub(xpub) => {
             //TODO check actual derivation matches
             match extract(input, xpub.root_fingerprint(secp)) {
@@ -891,10 +895,13 @@ impl<Ctx: ScriptContext + 'static> ExtractPolicy for Miniscript<DescriptorPublic
                 Some(Ctx::make_signature(pubkey_hash, signers, build_sat, secp))
             }
             Terminal::After(value) => {
-                let mut policy: Policy = SatisfiableItem::AbsoluteTimelock { value: *value }.into();
+                let mut policy: Policy = SatisfiableItem::AbsoluteTimelock {
+                    value: value.into(),
+                }
+                .into();
                 policy.contribution = Satisfaction::Complete {
                     condition: Condition {
-                        timelock: Some(*value),
+                        timelock: Some(value.into()),
                         csv: None,
                     },
                 };
@@ -905,9 +912,11 @@ impl<Ctx: ScriptContext + 'static> ExtractPolicy for Miniscript<DescriptorPublic
                 } = build_sat
                 {
                     let after = After::new(Some(current_height), false);
-                    let after_sat = Satisfier::<bitcoin::PublicKey>::check_after(&after, *value);
-                    let inputs_sat = psbt_inputs_sat(psbt)
-                        .all(|sat| Satisfier::<bitcoin::PublicKey>::check_after(&sat, *value));
+                    let after_sat =
+                        Satisfier::<bitcoin::PublicKey>::check_after(&after, value.into());
+                    let inputs_sat = psbt_inputs_sat(psbt).all(|sat| {
+                        Satisfier::<bitcoin::PublicKey>::check_after(&sat, value.into())
+                    });
                     if after_sat && inputs_sat {
                         policy.satisfaction = policy.contribution.clone();
                     }
@@ -999,6 +1008,9 @@ impl<Ctx: ScriptContext + 'static> ExtractPolicy for Miniscript<DescriptorPublic
 
                 Policy::make_thresh(mapped, threshold)?
             }
+
+            // Unsupported
+            Terminal::RawPkH(_) => None,
         })
     }
 }
@@ -1124,14 +1136,12 @@ mod test {
     use crate::descriptor::{ExtractPolicy, IntoWalletDescriptor};
 
     use super::*;
-    use crate::descriptor::derived::AsDerived;
     use crate::descriptor::policy::SatisfiableItem::{EcdsaSignature, Multisig, Thresh};
     use crate::keys::{DescriptorKey, IntoDescriptorKey};
     use crate::wallet::signer::SignersContainer;
     use bitcoin::secp256k1::Secp256k1;
     use bitcoin::util::bip32;
     use bitcoin::Network;
-    use miniscript::DescriptorTrait;
     use std::str::FromStr;
     use std::sync::Arc;
 
@@ -1329,9 +1339,8 @@ mod test {
         let (wallet_desc, keymap) = desc
             .into_wallet_descriptor(&secp, Network::Testnet)
             .unwrap();
-        let single_key = wallet_desc.derive(0);
         let signers_container = Arc::new(SignersContainer::build(keymap, &wallet_desc, &secp));
-        let policy = single_key
+        let policy = wallet_desc
             .extract_policy(&signers_container, BuildSatisfaction::None, &secp)
             .unwrap()
             .unwrap();
@@ -1343,16 +1352,15 @@ mod test {
         let (wallet_desc, keymap) = desc
             .into_wallet_descriptor(&secp, Network::Testnet)
             .unwrap();
-        let single_key = wallet_desc.derive(0);
         let signers_container = Arc::new(SignersContainer::build(keymap, &wallet_desc, &secp));
-        let policy = single_key
+        let policy = wallet_desc
             .extract_policy(&signers_container, BuildSatisfaction::None, &secp)
             .unwrap()
             .unwrap();
 
-        assert!(matches!(&policy.item, EcdsaSignature(PkOrF::Fingerprint(f)) if f == &fingerprint));
+        assert!(matches!(policy.item, EcdsaSignature(PkOrF::Fingerprint(f)) if f == fingerprint));
         assert!(
-            matches!(&policy.contribution, Satisfaction::Complete {condition} if condition.csv == None && condition.timelock == None)
+            matches!(policy.contribution, Satisfaction::Complete {condition} if condition.csv == None && condition.timelock == None)
         );
     }
 
@@ -1368,21 +1376,20 @@ mod test {
         let (wallet_desc, keymap) = desc
             .into_wallet_descriptor(&secp, Network::Testnet)
             .unwrap();
-        let single_key = wallet_desc.derive(0);
         let signers_container = Arc::new(SignersContainer::build(keymap, &wallet_desc, &secp));
-        let policy = single_key
+        let policy = wallet_desc
             .extract_policy(&signers_container, BuildSatisfaction::None, &secp)
             .unwrap()
             .unwrap();
 
         assert!(
-            matches!(&policy.item, Multisig { keys, threshold } if threshold == &1
+            matches!(policy.item, Multisig { keys, threshold } if threshold == 1
             && keys[0] == PkOrF::Fingerprint(fingerprint0)
             && keys[1] == PkOrF::Fingerprint(fingerprint1))
         );
         assert!(
-            matches!(&policy.contribution, Satisfaction::PartialComplete { n, m, items, conditions, .. } if n == &2
-             && m == &1
+            matches!(policy.contribution, Satisfaction::PartialComplete { n, m, items, conditions, .. } if n == 2
+             && m == 1
              && items.len() == 2
              && conditions.contains_key(&vec![0])
              && conditions.contains_key(&vec![1])
@@ -1427,8 +1434,8 @@ mod test {
              && m == &2
              && items.len() == 3
              && conditions.get(&vec![0,1]).unwrap().iter().next().unwrap().csv.is_none()
-             && conditions.get(&vec![0,2]).unwrap().iter().next().unwrap().csv == Some(sequence)
-             && conditions.get(&vec![1,2]).unwrap().iter().next().unwrap().csv == Some(sequence)
+             && conditions.get(&vec![0,2]).unwrap().iter().next().unwrap().csv == Some(Sequence(sequence))
+             && conditions.get(&vec![1,2]).unwrap().iter().next().unwrap().csv == Some(Sequence(sequence))
             )
         );
     }
@@ -1574,7 +1581,7 @@ mod test {
             .unwrap();
 
         let addr = wallet_desc
-            .as_derived(0, &secp)
+            .at_derivation_index(0)
             .address(Network::Testnet)
             .unwrap();
         assert_eq!(
@@ -1646,7 +1653,7 @@ mod test {
         let signers_container = Arc::new(SignersContainer::build(keymap, &wallet_desc, &secp));
 
         let addr = wallet_desc
-            .as_derived(0, &secp)
+            .at_derivation_index(0)
             .address(Network::Testnet)
             .unwrap();
         assert_eq!(

src/descriptor/template.rs

@@ -468,12 +468,10 @@ mod test {
     use std::str::FromStr;
 
     use super::*;
-    use crate::descriptor::derived::AsDerived;
     use crate::descriptor::{DescriptorError, DescriptorMeta};
     use crate::keys::ValidNetworks;
     use bitcoin::network::constants::Network::Regtest;
-    use bitcoin::secp256k1::Secp256k1;
-    use miniscript::descriptor::{DescriptorPublicKey, DescriptorTrait, KeyMap};
+    use miniscript::descriptor::{DescriptorPublicKey, KeyMap};
     use miniscript::Descriptor;
 
     // BIP44 `pkh(key/44'/{0,1}'/0'/{0,1}/*)`
@@ -517,17 +515,15 @@ mod test {
         is_fixed: bool,
         expected: &[&str],
     ) {
-        let secp = Secp256k1::new();
-
         let (desc, _key_map, _networks) = desc.unwrap();
         assert_eq!(desc.is_witness(), is_witness);
-        assert_eq!(!desc.is_deriveable(), is_fixed);
+        assert_eq!(!desc.has_wildcard(), is_fixed);
         for i in 0..expected.len() {
             let index = i as u32;
-            let child_desc = if !desc.is_deriveable() {
-                desc.as_derived_fixed(&secp)
+            let child_desc = if !desc.has_wildcard() {
+                desc.at_derivation_index(0)
             } else {
-                desc.as_derived(index, &secp)
+                desc.at_derivation_index(index)
             };
             let address = child_desc.address(Regtest).unwrap();
             assert_eq!(address.to_string(), *expected.get(i).unwrap());

src/error.rs

@@ -12,7 +12,7 @@
 use std::fmt;
 
 use crate::bitcoin::Network;
-use crate::{descriptor, wallet, wallet::address_validator};
+use crate::{descriptor, wallet};
 use bitcoin::{OutPoint, Txid};
 
 /// Errors that can be thrown by the [`Wallet`](crate::wallet::Wallet)
@@ -99,12 +99,12 @@ pub enum Error {
 
     /// Error related to the parsing and usage of descriptors
     Descriptor(crate::descriptor::error::Error),
-    /// Error that can be returned to fail the validation of an address
-    AddressValidator(crate::wallet::address_validator::AddressValidatorError),
     /// Encoding error
     Encode(bitcoin::consensus::encode::Error),
     /// Miniscript error
     Miniscript(miniscript::Error),
+    /// Miniscript PSBT error
+    MiniscriptPsbt(MiniscriptPsbtError),
     /// BIP32 error
     Bip32(bitcoin::util::bip32::Error),
     /// An ECDSA error
@@ -149,6 +149,14 @@ pub enum Error {
     Rusqlite(rusqlite::Error),
 }
 
+/// Errors returned by miniscript when updating inconsistent PSBTs
+#[derive(Debug, Clone)]
+pub enum MiniscriptPsbtError {
+    Conversion(miniscript::descriptor::ConversionError),
+    UtxoUpdate(miniscript::psbt::UtxoUpdateError),
+    OutputUpdate(miniscript::psbt::OutputUpdateError),
+}
+
 /// Represents the last failed [`crate::blockchain::WalletSync`] sync attempt in which we were short
 /// on cached `scriptPubKey`s.
 #[derive(Debug)]
@@ -181,7 +189,6 @@ macro_rules! impl_error {
 }
 
 impl_error!(descriptor::error::Error, Descriptor);
-impl_error!(address_validator::AddressValidatorError, AddressValidator);
 impl_error!(descriptor::policy::PolicyError, InvalidPolicyPathError);
 impl_error!(wallet::signer::SignerError, Signer);
 
@@ -198,6 +205,7 @@ impl From<crate::keys::KeyError> for Error {
 
 impl_error!(bitcoin::consensus::encode::Error, Encode);
 impl_error!(miniscript::Error, Miniscript);
+impl_error!(MiniscriptPsbtError, MiniscriptPsbt);
 impl_error!(bitcoin::util::bip32::Error, Bip32);
 impl_error!(bitcoin::secp256k1::Error, Secp256k1);
 impl_error!(serde_json::Error, Json);

src/keys/mod.rs

@@ -24,8 +24,8 @@ use bitcoin::{Network, PrivateKey, PublicKey, XOnlyPublicKey};
 
 use miniscript::descriptor::{Descriptor, DescriptorXKey, Wildcard};
 pub use miniscript::descriptor::{
-    DescriptorPublicKey, DescriptorSecretKey, DescriptorSinglePriv, DescriptorSinglePub, KeyMap,
-    SinglePubKey, SortedMultiVec,
+    DescriptorPublicKey, DescriptorSecretKey, KeyMap, SinglePriv, SinglePub, SinglePubKey,
+    SortedMultiVec,
 };
 pub use miniscript::ScriptContext;
 use miniscript::{Miniscript, Terminal};
@@ -110,7 +110,7 @@ impl<Ctx: ScriptContext> DescriptorKey<Ctx> {
                 let mut key_map = KeyMap::with_capacity(1);
 
                 let public = secret
-                    .as_public(secp)
+                    .to_public(secp)
                     .map_err(|e| miniscript::Error::Unexpected(e.to_string()))?;
                 key_map.insert(public.clone(), secret);
 
@@ -224,8 +224,8 @@ impl<Ctx: ScriptContext + 'static> ExtScriptContext for Ctx {
 /// use bdk::bitcoin::PublicKey;
 ///
 /// use bdk::keys::{
-///     mainnet_network, DescriptorKey, DescriptorPublicKey, DescriptorSinglePub,
-///     IntoDescriptorKey, KeyError, ScriptContext, SinglePubKey,
+///     mainnet_network, DescriptorKey, DescriptorPublicKey, IntoDescriptorKey, KeyError,
+///     ScriptContext, SinglePub, SinglePubKey,
 /// };
 ///
 /// pub struct MyKeyType {
@@ -235,7 +235,7 @@ impl<Ctx: ScriptContext + 'static> ExtScriptContext for Ctx {
 /// impl<Ctx: ScriptContext> IntoDescriptorKey<Ctx> for MyKeyType {
 ///     fn into_descriptor_key(self) -> Result<DescriptorKey<Ctx>, KeyError> {
 ///         Ok(DescriptorKey::from_public(
-///             DescriptorPublicKey::SinglePub(DescriptorSinglePub {
+///             DescriptorPublicKey::Single(SinglePub {
 ///                 origin: None,
 ///                 key: SinglePubKey::FullKey(self.pubkey),
 ///             }),
@@ -842,7 +842,7 @@ impl<Ctx: ScriptContext> IntoDescriptorKey<Ctx> for DescriptorKey<Ctx> {
 impl<Ctx: ScriptContext> IntoDescriptorKey<Ctx> for DescriptorPublicKey {
     fn into_descriptor_key(self) -> Result<DescriptorKey<Ctx>, KeyError> {
         let networks = match self {
-            DescriptorPublicKey::SinglePub(_) => any_network(),
+            DescriptorPublicKey::Single(_) => any_network(),
             DescriptorPublicKey::XPub(DescriptorXKey { xkey, .. })
                 if xkey.network == Network::Bitcoin =>
             {
@@ -857,7 +857,7 @@ impl<Ctx: ScriptContext> IntoDescriptorKey<Ctx> for DescriptorPublicKey {
 
 impl<Ctx: ScriptContext> IntoDescriptorKey<Ctx> for PublicKey {
     fn into_descriptor_key(self) -> Result<DescriptorKey<Ctx>, KeyError> {
-        DescriptorPublicKey::SinglePub(DescriptorSinglePub {
+        DescriptorPublicKey::Single(SinglePub {
             key: SinglePubKey::FullKey(self),
             origin: None,
         })
@@ -867,7 +867,7 @@ impl<Ctx: ScriptContext> IntoDescriptorKey<Ctx> for PublicKey {
 
 impl<Ctx: ScriptContext> IntoDescriptorKey<Ctx> for XOnlyPublicKey {
     fn into_descriptor_key(self) -> Result<DescriptorKey<Ctx>, KeyError> {
-        DescriptorPublicKey::SinglePub(DescriptorSinglePub {
+        DescriptorPublicKey::Single(SinglePub {
             key: SinglePubKey::XOnly(self),
             origin: None,
         })
@@ -878,7 +878,7 @@ impl<Ctx: ScriptContext> IntoDescriptorKey<Ctx> for XOnlyPublicKey {
 impl<Ctx: ScriptContext> IntoDescriptorKey<Ctx> for DescriptorSecretKey {
     fn into_descriptor_key(self) -> Result<DescriptorKey<Ctx>, KeyError> {
         let networks = match &self {
-            DescriptorSecretKey::SinglePriv(sk) if sk.key.network == Network::Bitcoin => {
+            DescriptorSecretKey::Single(sk) if sk.key.network == Network::Bitcoin => {
                 mainnet_network()
             }
             DescriptorSecretKey::XPrv(DescriptorXKey { xkey, .. })
@@ -903,7 +903,7 @@ impl<Ctx: ScriptContext> IntoDescriptorKey<Ctx> for &'_ str {
 
 impl<Ctx: ScriptContext> IntoDescriptorKey<Ctx> for PrivateKey {
     fn into_descriptor_key(self) -> Result<DescriptorKey<Ctx>, KeyError> {
-        DescriptorSecretKey::SinglePriv(DescriptorSinglePriv {
+        DescriptorSecretKey::Single(SinglePriv {
             key: self,
             origin: None,
         })

src/lib.rs

@@ -203,6 +203,8 @@ pub extern crate miniscript;
 extern crate serde;
 #[macro_use]
 extern crate serde_json;
+#[cfg(feature = "hardware-signer")]
+pub extern crate hwi;
 
 #[cfg(all(feature = "reqwest", feature = "ureq"))]
 compile_error!("Features reqwest and ureq are mutually exclusive and cannot be enabled together");
@@ -231,15 +233,15 @@ extern crate async_trait;
 #[macro_use]
 extern crate bdk_macros;
 
-#[cfg(feature = "compact_filters")]
-extern crate lazy_static;
-
 #[cfg(feature = "rpc")]
 pub extern crate bitcoincore_rpc;
 
 #[cfg(feature = "electrum")]
 pub extern crate electrum_client;
 
+#[cfg(feature = "esplora")]
+pub extern crate esplora_client;
+
 #[cfg(feature = "key-value-db")]
 pub extern crate sled;
 
@@ -263,7 +265,7 @@ pub mod descriptor;
 #[cfg(feature = "test-md-docs")]
 mod doctest;
 pub mod keys;
-pub(crate) mod psbt;
+pub mod psbt;
 pub(crate) mod types;
 pub mod wallet;
 
@@ -271,7 +273,6 @@ pub use descriptor::template;
 pub use descriptor::HdKeyPaths;
 pub use error::Error;
 pub use types::*;
-pub use wallet::address_validator;
 pub use wallet::signer;
 pub use wallet::signer::SignOptions;
 pub use wallet::tx_builder::TxBuilder;

src/psbt/mod.rs

@@ -9,11 +9,28 @@
 // You may not use this file except in accordance with one or both of these
 // licenses.
 
+//! Additional functions on the `rust-bitcoin` `PartiallySignedTransaction` structure.
+
+use crate::FeeRate;
 use bitcoin::util::psbt::PartiallySignedTransaction as Psbt;
 use bitcoin::TxOut;
 
+// TODO upstream the functions here to `rust-bitcoin`?
+
+/// Trait to add functions to extract utxos and calculate fees.
 pub trait PsbtUtils {
+    /// Get the `TxOut` for the specified input index, if it doesn't exist in the PSBT `None` is returned.
     fn get_utxo_for(&self, input_index: usize) -> Option<TxOut>;
+
+    /// The total transaction fee amount, sum of input amounts minus sum of output amounts, in Sats.
+    /// If the PSBT is missing a TxOut for an input returns None.
+    fn fee_amount(&self) -> Option<u64>;
+
+    /// The transaction's fee rate. This value will only be accurate if calculated AFTER the
+    /// `PartiallySignedTransaction` is finalized and all witness/signature data is added to the
+    /// transaction.
+    /// If the PSBT is missing a TxOut for an input returns None.
+    fn fee_rate(&self) -> Option<FeeRate>;
 }
 
 impl PsbtUtils for Psbt {
@@ -37,6 +54,27 @@ impl PsbtUtils for Psbt {
             None
         }
     }
+
+    fn fee_amount(&self) -> Option<u64> {
+        let tx = &self.unsigned_tx;
+        let utxos: Option<Vec<TxOut>> = (0..tx.input.len()).map(|i| self.get_utxo_for(i)).collect();
+
+        utxos.map(|inputs| {
+            let input_amount: u64 = inputs.iter().map(|i| i.value).sum();
+            let output_amount: u64 = self.unsigned_tx.output.iter().map(|o| o.value).sum();
+            input_amount
+                .checked_sub(output_amount)
+                .expect("input amount must be greater than output amount")
+        })
+    }
+
+    fn fee_rate(&self) -> Option<FeeRate> {
+        let fee_amount = self.fee_amount();
+        fee_amount.map(|fee| {
+            let weight = self.clone().extract_tx().weight();
+            FeeRate::from_wu(fee, weight)
+        })
+    }
 }
 
 #[cfg(test)]
@@ -44,8 +82,9 @@ mod test {
     use crate::bitcoin::TxIn;
     use crate::psbt::Psbt;
     use crate::wallet::AddressIndex;
+    use crate::wallet::AddressIndex::New;
     use crate::wallet::{get_funded_wallet, test::get_test_wpkh};
-    use crate::SignOptions;
+    use crate::{psbt, FeeRate, SignOptions};
     use std::str::FromStr;
 
     // from bip 174
@@ -118,4 +157,83 @@ mod test {
 
         let _ = wallet.sign(&mut psbt, SignOptions::default()).unwrap();
     }
+
+    #[test]
+    fn test_psbt_fee_rate_with_witness_utxo() {
+        use psbt::PsbtUtils;
+
+        let expected_fee_rate = 1.2345;
+
+        let (wallet, _, _) = get_funded_wallet("wpkh(tprv8ZgxMBicQKsPd3EupYiPRhaMooHKUHJxNsTfYuScep13go8QFfHdtkG9nRkFGb7busX4isf6X9dURGCoKgitaApQ6MupRhZMcELAxTBRJgS/*)");
+        let addr = wallet.get_address(New).unwrap();
+        let mut builder = wallet.build_tx();
+        builder.drain_to(addr.script_pubkey()).drain_wallet();
+        builder.fee_rate(FeeRate::from_sat_per_vb(expected_fee_rate));
+        let (mut psbt, _) = builder.finish().unwrap();
+        let fee_amount = psbt.fee_amount();
+        assert!(fee_amount.is_some());
+
+        let unfinalized_fee_rate = psbt.fee_rate().unwrap();
+
+        let finalized = wallet.sign(&mut psbt, Default::default()).unwrap();
+        assert!(finalized);
+
+        let finalized_fee_rate = psbt.fee_rate().unwrap();
+        assert!(finalized_fee_rate.as_sat_per_vb() >= expected_fee_rate);
+        assert!(finalized_fee_rate.as_sat_per_vb() < unfinalized_fee_rate.as_sat_per_vb());
+    }
+
+    #[test]
+    fn test_psbt_fee_rate_with_nonwitness_utxo() {
+        use psbt::PsbtUtils;
+
+        let expected_fee_rate = 1.2345;
+
+        let (wallet, _, _) = get_funded_wallet("pkh(tprv8ZgxMBicQKsPd3EupYiPRhaMooHKUHJxNsTfYuScep13go8QFfHdtkG9nRkFGb7busX4isf6X9dURGCoKgitaApQ6MupRhZMcELAxTBRJgS/*)");
+        let addr = wallet.get_address(New).unwrap();
+        let mut builder = wallet.build_tx();
+        builder.drain_to(addr.script_pubkey()).drain_wallet();
+        builder.fee_rate(FeeRate::from_sat_per_vb(expected_fee_rate));
+        let (mut psbt, _) = builder.finish().unwrap();
+        let fee_amount = psbt.fee_amount();
+        assert!(fee_amount.is_some());
+        let unfinalized_fee_rate = psbt.fee_rate().unwrap();
+
+        let finalized = wallet.sign(&mut psbt, Default::default()).unwrap();
+        assert!(finalized);
+
+        let finalized_fee_rate = psbt.fee_rate().unwrap();
+        assert!(finalized_fee_rate.as_sat_per_vb() >= expected_fee_rate);
+        assert!(finalized_fee_rate.as_sat_per_vb() < unfinalized_fee_rate.as_sat_per_vb());
+    }
+
+    #[test]
+    fn test_psbt_fee_rate_with_missing_txout() {
+        use psbt::PsbtUtils;
+
+        let expected_fee_rate = 1.2345;
+
+        let (wpkh_wallet, _, _) = get_funded_wallet("wpkh(tprv8ZgxMBicQKsPd3EupYiPRhaMooHKUHJxNsTfYuScep13go8QFfHdtkG9nRkFGb7busX4isf6X9dURGCoKgitaApQ6MupRhZMcELAxTBRJgS/*)");
+        let addr = wpkh_wallet.get_address(New).unwrap();
+        let mut builder = wpkh_wallet.build_tx();
+        builder.drain_to(addr.script_pubkey()).drain_wallet();
+        builder.fee_rate(FeeRate::from_sat_per_vb(expected_fee_rate));
+        let (mut wpkh_psbt, _) = builder.finish().unwrap();
+
+        wpkh_psbt.inputs[0].witness_utxo = None;
+        wpkh_psbt.inputs[0].non_witness_utxo = None;
+        assert!(wpkh_psbt.fee_amount().is_none());
+        assert!(wpkh_psbt.fee_rate().is_none());
+
+        let (pkh_wallet, _, _) = get_funded_wallet("pkh(tprv8ZgxMBicQKsPd3EupYiPRhaMooHKUHJxNsTfYuScep13go8QFfHdtkG9nRkFGb7busX4isf6X9dURGCoKgitaApQ6MupRhZMcELAxTBRJgS/*)");
+        let addr = pkh_wallet.get_address(New).unwrap();
+        let mut builder = pkh_wallet.build_tx();
+        builder.drain_to(addr.script_pubkey()).drain_wallet();
+        builder.fee_rate(FeeRate::from_sat_per_vb(expected_fee_rate));
+        let (mut pkh_psbt, _) = builder.finish().unwrap();
+
+        pkh_psbt.inputs[0].non_witness_utxo = None;
+        assert!(pkh_psbt.fee_amount().is_none());
+        assert!(pkh_psbt.fee_rate().is_none());
+    }
 }

src/testutils/blockchain_tests.rs

@@ -1,8 +1,18 @@
+// Bitcoin Dev Kit
+//
+// Copyright (c) 2020-2021 Bitcoin Dev Kit Developers
+//
+// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
+// or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
+// You may not use this file except in accordance with one or both of these
+// licenses.
+
 use crate::testutils::TestIncomingTx;
 use bitcoin::consensus::encode::{deserialize, serialize};
 use bitcoin::hashes::hex::{FromHex, ToHex};
 use bitcoin::hashes::sha256d;
-use bitcoin::{Address, Amount, Script, Transaction, Txid, Witness};
+use bitcoin::{Address, Amount, PackedLockTime, Script, Sequence, Transaction, Txid, Witness};
 pub use bitcoincore_rpc::bitcoincore_rpc_json::AddressType;
 pub use bitcoincore_rpc::{Auth, Client as RpcClient, RpcApi};
 use core::str::FromStr;
@@ -110,7 +120,7 @@ impl TestClient {
         if let Some(true) = meta_tx.replaceable {
             // for some reason core doesn't set this field right
             for input in &mut tx.input {
-                input.sequence = 0xFFFFFFFD;
+                input.sequence = Sequence(0xFFFFFFFD);
             }
         }
 
@@ -164,6 +174,7 @@ impl TestClient {
         use bitcoin::blockdata::script::Builder;
         use bitcoin::blockdata::transaction::{OutPoint, TxIn, TxOut};
         use bitcoin::hash_types::{BlockHash, TxMerkleNode};
+        use bitcoin::hashes::Hash;
 
         let block_template: serde_json::Value = self
             .call("getblocktemplate", &[json!({"rules": ["segwit"]})])
@@ -176,7 +187,7 @@ impl TestClient {
                 block_template["previousblockhash"].as_str().unwrap(),
             )
             .unwrap(),
-            merkle_root: TxMerkleNode::default(),
+            merkle_root: TxMerkleNode::all_zeros(),
             time: block_template["curtime"].as_u64().unwrap() as u32,
             bits: u32::from_str_radix(block_template["bits"].as_str().unwrap(), 16).unwrap(),
             nonce: 0,
@@ -184,15 +195,15 @@ impl TestClient {
         debug!("header: {:#?}", header);
 
         let height = block_template["height"].as_u64().unwrap() as i64;
-        let witness_reserved_value: Vec<u8> = sha256d::Hash::default().as_ref().into();
+        let witness_reserved_value: Vec<u8> = sha256d::Hash::all_zeros().as_ref().into();
         // burn block subsidy and fees, not a big deal
         let mut coinbase_tx = Transaction {
             version: 1,
-            lock_time: 0,
+            lock_time: PackedLockTime(0),
             input: vec![TxIn {
                 previous_output: OutPoint::null(),
                 script_sig: Builder::new().push_int(height).into_script(),
-                sequence: 0xFFFFFFFF,
+                sequence: Sequence(0xFFFFFFFF),
                 witness: Witness::from_vec(vec![witness_reserved_value]),
             }],
             output: vec![],
@@ -1184,7 +1195,7 @@ macro_rules! bdk_blockchain_tests {
                 // 5. Verify 25_000 sats are received by test bitcoind node taproot wallet
 
                 let taproot_balance = taproot_wallet_client.get_balance(None, None).unwrap();
-                assert_eq!(taproot_balance.as_sat(), 25_000, "node has incorrect taproot wallet balance");
+                assert_eq!(taproot_balance.to_sat(), 25_000, "node has incorrect taproot wallet balance");
             }
 
             #[test]

src/testutils/mod.rs

@@ -101,25 +101,21 @@ impl TestIncomingTx {
 macro_rules! testutils {
     ( @external $descriptors:expr, $child:expr ) => ({
         use $crate::bitcoin::secp256k1::Secp256k1;
-        use $crate::miniscript::descriptor::{Descriptor, DescriptorPublicKey, DescriptorTrait};
-
-        use $crate::descriptor::AsDerived;
+        use $crate::miniscript::descriptor::{Descriptor, DescriptorPublicKey};
 
         let secp = Secp256k1::new();
 
         let parsed = Descriptor::<DescriptorPublicKey>::parse_descriptor(&secp, &$descriptors.0).expect("Failed to parse descriptor in `testutils!(@external)`").0;
-        parsed.as_derived($child, &secp).address(bitcoin::Network::Regtest).expect("No address form")
+        parsed.at_derivation_index($child).address(bitcoin::Network::Regtest).expect("No address form")
     });
     ( @internal $descriptors:expr, $child:expr ) => ({
         use $crate::bitcoin::secp256k1::Secp256k1;
-        use $crate::miniscript::descriptor::{Descriptor, DescriptorPublicKey, DescriptorTrait};
-
-        use $crate::descriptor::AsDerived;
+        use $crate::miniscript::descriptor::{Descriptor, DescriptorPublicKey};
 
         let secp = Secp256k1::new();
 
         let parsed = Descriptor::<DescriptorPublicKey>::parse_descriptor(&secp, &$descriptors.1.expect("Missing internal descriptor")).expect("Failed to parse descriptor in `testutils!(@internal)`").0;
-        parsed.as_derived($child, &secp).address($crate::bitcoin::Network::Regtest).expect("No address form")
+        parsed.at_derivation_index($child).address($crate::bitcoin::Network::Regtest).expect("No address form")
     });
     ( @e $descriptors:expr, $child:expr ) => ({ testutils!(@external $descriptors, $child) });
     ( @i $descriptors:expr, $child:expr ) => ({ testutils!(@internal $descriptors, $child) });
@@ -186,49 +182,50 @@ macro_rules! testutils {
     ( @descriptors ( $external_descriptor:expr ) $( ( $internal_descriptor:expr ) )? $( ( @keys $( $keys:tt )* ) )* ) => ({
         use std::str::FromStr;
         use std::collections::HashMap;
+        use std::convert::Infallible;
+
         use $crate::miniscript::descriptor::Descriptor;
         use $crate::miniscript::TranslatePk;
 
+        struct Translator {
+            keys: HashMap<&'static str, (String, Option<String>, Option<String>)>,
+            is_internal: bool,
+        }
+
+        impl $crate::miniscript::Translator<String, String, Infallible> for Translator {
+            fn pk(&mut self, pk: &String) -> Result<String, Infallible> {
+                match self.keys.get(pk.as_str()) {
+                    Some((key, ext_path, int_path)) => {
+                        let path = if self.is_internal { int_path } else { ext_path };
+                        Ok(format!("{}{}", key, path.clone().unwrap_or_default()))
+                    }
+                    None => Ok(pk.clone()),
+                }
+            }
+            fn sha256(&mut self, sha256: &String) -> Result<String, Infallible> { Ok(sha256.clone()) }
+            fn hash256(&mut self, hash256: &String) -> Result<String, Infallible> { Ok(hash256.clone()) }
+            fn ripemd160(&mut self, ripemd160: &String) -> Result<String, Infallible> { Ok(ripemd160.clone()) }
+            fn hash160(&mut self, hash160: &String) -> Result<String, Infallible> { Ok(hash160.clone()) }
+        }
+
         #[allow(unused_assignments, unused_mut)]
-        let mut keys: HashMap<&'static str, (String, Option<String>, Option<String>)> = HashMap::new();
+        let mut keys = HashMap::new();
         $(
             keys = testutils!{ @keys $( $keys )* };
         )*
 
-        let external: Descriptor<String> = FromStr::from_str($external_descriptor).unwrap();
-        let external: Descriptor<String> = external.translate_pk_infallible::<_, _>(|k| {
-            if let Some((key, ext_path, _)) = keys.get(&k.as_str()) {
-                format!("{}{}", key, ext_path.as_ref().unwrap_or(&"".into()))
-            } else {
-                k.clone()
-            }
-        }, |kh| {
-            if let Some((key, ext_path, _)) = keys.get(&kh.as_str()) {
-                format!("{}{}", key, ext_path.as_ref().unwrap_or(&"".into()))
-            } else {
-                kh.clone()
-            }
+        let mut translator = Translator { keys, is_internal: false };
 
-        });
+        let external: Descriptor<String> = FromStr::from_str($external_descriptor).unwrap();
+        let external = external.translate_pk(&mut translator).expect("Infallible conversion");
         let external = external.to_string();
 
-        let internal = None::<String>$(.or({
-            let string_internal: Descriptor<String> = FromStr::from_str($internal_descriptor).unwrap();
+        translator.is_internal = true;
 
-            let string_internal: Descriptor<String> = string_internal.translate_pk_infallible::<_, _>(|k| {
-                if let Some((key, _, int_path)) = keys.get(&k.as_str()) {
-                    format!("{}{}", key, int_path.as_ref().unwrap_or(&"".into()))
-                } else {
-                    k.clone()
-                }
-            }, |kh| {
-                if let Some((key, _, int_path)) = keys.get(&kh.as_str()) {
-                    format!("{}{}", key, int_path.as_ref().unwrap_or(&"".into()))
-                } else {
-                    kh.clone()
-                }
-            });
-            Some(string_internal.to_string())
+        let internal = None::<String>$(.or({
+            let internal: Descriptor<String> = FromStr::from_str($internal_descriptor).unwrap();
+            let internal = internal.translate_pk(&mut translator).expect("Infallible conversion");
+            Some(internal.to_string())
         }))?;
 
         (external, internal)

src/types.rs

@@ -166,7 +166,7 @@ pub struct LocalUtxo {
 }
 
 /// A [`Utxo`] with its `satisfaction_weight`.
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct WeightedUtxo {
     /// The weight of the witness data and `scriptSig` expressed in [weight units]. This is used to
     /// properly maintain the feerate when adding this input to a transaction during coin selection.
@@ -177,7 +177,7 @@ pub struct WeightedUtxo {
     pub utxo: Utxo,
 }
 
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 /// An unspent transaction output (UTXO).
 pub enum Utxo {
     /// A UTXO owned by the local wallet.
@@ -224,7 +224,7 @@ impl Utxo {
 }
 
 /// A wallet transaction
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Default)]
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
 pub struct TransactionDetails {
     /// Optional transaction
     pub transaction: Option<Transaction>,

src/wallet/address_validator.rs

@@ -1,158 +0,0 @@
-// Bitcoin Dev Kit
-// Written in 2020 by Alekos Filini <alekos.filini@gmail.com>
-//
-// Copyright (c) 2020-2021 Bitcoin Dev Kit Developers
-//
-// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
-// or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
-// You may not use this file except in accordance with one or both of these
-// licenses.
-
-//! Address validation callbacks
-//!
-//! The typical usage of those callbacks is for displaying the newly-generated address on a
-//! hardware wallet, so that the user can cross-check its correctness.
-//!
-//! More generally speaking though, these callbacks can also be used to "do something" every time
-//! an address is generated, without necessarily checking or validating it.
-//!
-//! An address validator can be attached to a [`Wallet`](super::Wallet) by using the
-//! [`Wallet::add_address_validator`](super::Wallet::add_address_validator) method, and
-//! whenever a new address is generated (either explicitly by the user with
-//! [`Wallet::get_address`](super::Wallet::get_address) or internally to create a change
-//! address) all the attached validators will be polled, in sequence. All of them must complete
-//! successfully to continue.
-//!
-//! ## Example
-//!
-//! ```
-//! # use std::sync::Arc;
-//! # use bitcoin::*;
-//! # use bdk::address_validator::*;
-//! # use bdk::database::*;
-//! # use bdk::*;
-//! # use bdk::wallet::AddressIndex::New;
-//! #[derive(Debug)]
-//! struct PrintAddressAndContinue;
-//!
-//! impl AddressValidator for PrintAddressAndContinue {
-//!     fn validate(
-//!         &self,
-//!         keychain: KeychainKind,
-//!         hd_keypaths: &HdKeyPaths,
-//!         script: &Script
-//!     ) -> Result<(), AddressValidatorError> {
-//!         let address = Address::from_script(script, Network::Testnet)
-//!             .as_ref()
-//!             .map(Address::to_string)
-//!             .unwrap_or(script.to_string());
-//!         println!("New address of type {:?}: {}", keychain, address);
-//!         println!("HD keypaths: {:#?}", hd_keypaths);
-//!
-//!         Ok(())
-//!     }
-//! }
-//!
-//! let descriptor = "wpkh(tpubD6NzVbkrYhZ4Xferm7Pz4VnjdcDPFyjVu5K4iZXQ4pVN8Cks4pHVowTBXBKRhX64pkRyJZJN5xAKj4UDNnLPb5p2sSKXhewoYx5GbTdUFWq/*)";
-//! let mut wallet = Wallet::new(descriptor, None, Network::Testnet, MemoryDatabase::default())?;
-//! wallet.add_address_validator(Arc::new(PrintAddressAndContinue));
-//!
-//! let address = wallet.get_address(New)?;
-//! println!("Address: {}", address);
-//! # Ok::<(), bdk::Error>(())
-//! ```
-
-use std::fmt;
-
-use bitcoin::Script;
-
-use crate::descriptor::HdKeyPaths;
-use crate::types::KeychainKind;
-
-/// Errors that can be returned to fail the validation of an address
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum AddressValidatorError {
-    /// User rejected the address
-    UserRejected,
-    /// Network connection error
-    ConnectionError,
-    /// Network request timeout error
-    TimeoutError,
-    /// Invalid script
-    InvalidScript,
-    /// A custom error message
-    Message(String),
-}
-
-impl fmt::Display for AddressValidatorError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{:?}", self)
-    }
-}
-
-impl std::error::Error for AddressValidatorError {}
-
-/// Trait to build address validators
-///
-/// All the address validators attached to a wallet with [`Wallet::add_address_validator`](super::Wallet::add_address_validator) will be polled
-/// every time an address (external or internal) is generated by the wallet. Errors returned in the
-/// validator will be propagated up to the original caller that triggered the address generation.
-///
-/// For a usage example see [this module](crate::address_validator)'s documentation.
-#[deprecated = "AddressValidator was rarely used. Address validation can occur outside of BDK"]
-pub trait AddressValidator: Send + Sync + fmt::Debug {
-    /// Validate or inspect an address
-    fn validate(
-        &self,
-        keychain: KeychainKind,
-        hd_keypaths: &HdKeyPaths,
-        script: &Script,
-    ) -> Result<(), AddressValidatorError>;
-}
-
-#[cfg(test)]
-mod test {
-    use std::sync::Arc;
-
-    use super::*;
-    use crate::wallet::AddressIndex::New;
-    use crate::wallet::{get_funded_wallet, test::get_test_wpkh};
-
-    #[derive(Debug)]
-    struct TestValidator;
-    #[allow(deprecated)]
-    impl AddressValidator for TestValidator {
-        fn validate(
-            &self,
-            _keychain: KeychainKind,
-            _hd_keypaths: &HdKeyPaths,
-            _script: &bitcoin::Script,
-        ) -> Result<(), AddressValidatorError> {
-            Err(AddressValidatorError::InvalidScript)
-        }
-    }
-
-    #[test]
-    #[should_panic(expected = "InvalidScript")]
-    fn test_address_validator_external() {
-        let (mut wallet, _, _) = get_funded_wallet(get_test_wpkh());
-        #[allow(deprecated)]
-        wallet.add_address_validator(Arc::new(TestValidator));
-
-        wallet.get_address(New).unwrap();
-    }
-
-    #[test]
-    #[should_panic(expected = "InvalidScript")]
-    fn test_address_validator_internal() {
-        let (mut wallet, descriptors, _) = get_funded_wallet(get_test_wpkh());
-        #[allow(deprecated)]
-        wallet.add_address_validator(Arc::new(TestValidator));
-
-        let addr = crate::testutils!(@external descriptors, 10);
-        let mut builder = wallet.build_tx();
-        builder.add_recipient(addr.script_pubkey(), 25_000);
-        builder.finish().unwrap();
-    }
-}

src/wallet/coin_selection.rs

@@ -310,7 +310,7 @@ pub fn decide_change(remaining_amount: u64, fee_rate: FeeRate, drain_script: &Sc
     let drain_val = remaining_amount.saturating_sub(change_fee);
 
     if drain_val.is_dust(drain_script) {
-        let dust_threshold = drain_script.dust_value().as_sat();
+        let dust_threshold = drain_script.dust_value().to_sat();
         Excess::NoChange {
             dust_threshold,
             change_fee,
@@ -835,7 +835,7 @@ mod test {
                     )
                     .unwrap(),
                     txout: TxOut {
-                        value: rng.gen_range(0, 200000000),
+                        value: rng.gen_range(0..200000000),
                         script_pubkey: Script::new(),
                     },
                     keychain: KeychainKind::External,
@@ -866,7 +866,7 @@ mod test {
     }
 
     fn sum_random_utxos(mut rng: &mut StdRng, utxos: &mut Vec<WeightedUtxo>) -> u64 {
-        let utxos_picked_len = rng.gen_range(2, utxos.len() / 2);
+        let utxos_picked_len = rng.gen_range(2..utxos.len() / 2);
         utxos.shuffle(&mut rng);
         utxos[..utxos_picked_len]
             .iter()
@@ -1226,6 +1226,7 @@ mod test {
     }
 
     #[test]
+    #[ignore]
     fn test_bnb_coin_selection_required_not_enough() {
         let utxos = get_test_utxos();
         let database = MemoryDatabase::default();

src/wallet/export.rs

@@ -134,15 +134,11 @@ impl FullyNodedExport {
         let blockheight = match wallet.database.borrow().iter_txs(false) {
             _ if !include_blockheight => 0,
             Err(_) => 0,
-            Ok(txs) => {
-                let mut heights = txs
-                    .into_iter()
-                    .map(|tx| tx.confirmation_time.map(|c| c.height).unwrap_or(0))
-                    .collect::<Vec<_>>();
-                heights.sort_unstable();
-
-                *heights.last().unwrap_or(&0)
-            }
+            Ok(txs) => txs
+                .into_iter()
+                .filter_map(|tx| tx.confirmation_time.map(|c| c.height))
+                .min()
+                .unwrap_or(0),
         };
 
         let export = FullyNodedExport {
@@ -249,6 +245,22 @@ mod test {
             fee: Some(500),
             confirmation_time: Some(BlockTime {
                 timestamp: 12345678,
+                height: 5001,
+            }),
+        })
+        .unwrap();
+
+        db.set_tx(&TransactionDetails {
+            transaction: None,
+            txid: Txid::from_str(
+                "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+            )
+            .unwrap(),
+            received: 25_000,
+            sent: 0,
+            fee: Some(300),
+            confirmation_time: Some(BlockTime {
+                timestamp: 12345677,
                 height: 5000,
             }),
         })

src/wallet/hardwaresigner.rs

@@ -11,7 +11,40 @@
 
 //! HWI Signer
 //!
-//! This module contains a simple implementation of a Custom signer for rust-hwi
+//! This module contains HWISigner, an implementation of a [TransactionSigner] to be
+//! used with hardware wallets.
+//! ```no_run
+//! # use bdk::bitcoin::Network;
+//! # use bdk::database::MemoryDatabase;
+//! # use bdk::signer::SignerOrdering;
+//! # use bdk::wallet::hardwaresigner::HWISigner;
+//! # use bdk::wallet::AddressIndex::New;
+//! # use bdk::{FeeRate, KeychainKind, SignOptions, SyncOptions, Wallet};
+//! # use hwi::{types::HWIChain, HWIClient};
+//! # use std::sync::Arc;
+//! #
+//! # fn main() -> Result<(), Box<dyn std::error::Error>> {
+//! let devices = HWIClient::enumerate()?;
+//! let first_device = devices.first().expect("No devices found!");
+//! let custom_signer = HWISigner::from_device(first_device, HWIChain::Test)?;
+//!
+//! # let mut wallet = Wallet::new(
+//! #     "",
+//! #     None,
+//! #     Network::Testnet,
+//! #     MemoryDatabase::default(),
+//! # )?;
+//! #
+//! // Adding the hardware signer to the BDK wallet
+//! wallet.add_signer(
+//!     KeychainKind::External,
+//!     SignerOrdering(200),
+//!     Arc::new(custom_signer),
+//! );
+//!
+//! # Ok(())
+//! # }
+//! ```
 
 use bitcoin::psbt::PartiallySignedTransaction;
 use bitcoin::secp256k1::{All, Secp256k1};

src/wallet/signer.rs

@@ -96,13 +96,14 @@ use bitcoin::{secp256k1, XOnlyPublicKey};
 use bitcoin::{EcdsaSighashType, PrivateKey, PublicKey, SchnorrSighashType, Script};
 
 use miniscript::descriptor::{
-    Descriptor, DescriptorPublicKey, DescriptorSecretKey, DescriptorSinglePriv, DescriptorXKey,
-    KeyMap, SinglePubKey,
+    Descriptor, DescriptorPublicKey, DescriptorSecretKey, DescriptorXKey, KeyMap, SinglePriv,
+    SinglePubKey,
 };
-use miniscript::{Legacy, MiniscriptKey, Segwitv0, Tap};
+use miniscript::{Legacy, Segwitv0, SigType, Tap, ToPublicKey};
 
 use super::utils::SecpCtx;
 use crate::descriptor::{DescriptorMeta, XKeyUtils};
+use crate::psbt::PsbtUtils;
 
 /// Identifier of a signer in the `SignersContainers`. Used as a key to find the right signer among
 /// multiple of them
@@ -368,11 +369,11 @@ impl InputSigner for SignerWrapper<DescriptorXKey<ExtendedPrivKey>> {
 
 impl SignerCommon for SignerWrapper<PrivateKey> {
     fn id(&self, secp: &SecpCtx) -> SignerId {
-        SignerId::from(self.public_key(secp).to_pubkeyhash())
+        SignerId::from(self.public_key(secp).to_pubkeyhash(SigType::Ecdsa))
     }
 
     fn descriptor_secret_key(&self) -> Option<DescriptorSecretKey> {
-        Some(DescriptorSecretKey::SinglePriv(DescriptorSinglePriv {
+        Some(DescriptorSecretKey::Single(SinglePriv {
             key: self.signer,
             origin: None,
         }))
@@ -471,6 +472,7 @@ impl InputSigner for SignerWrapper<PrivateKey> {
             hash,
             hash_ty,
             secp,
+            sign_options.allow_grinding,
         );
 
         Ok(())
@@ -484,9 +486,14 @@ fn sign_psbt_ecdsa(
     hash: bitcoin::Sighash,
     hash_ty: EcdsaSighashType,
     secp: &SecpCtx,
+    allow_grinding: bool,
 ) {
     let msg = &Message::from_slice(&hash.into_inner()[..]).unwrap();
-    let sig = secp.sign_ecdsa(msg, secret_key);
+    let sig = if allow_grinding {
+        secp.sign_ecdsa_low_r(msg, secret_key)
+    } else {
+        secp.sign_ecdsa(msg, secret_key)
+    };
     secp.verify_ecdsa(msg, &sig, &pubkey.inner)
         .expect("invalid or corrupted ecdsa signature");
 
@@ -510,13 +517,13 @@ fn sign_psbt_schnorr(
     let keypair = match leaf_hash {
         None => keypair
             .tap_tweak(secp, psbt_input.tap_merkle_root)
-            .into_inner(),
+            .to_inner(),
         Some(_) => keypair, // no tweak for script spend
     };
 
     let msg = &Message::from_slice(&hash.into_inner()[..]).unwrap();
     let sig = secp.sign_schnorr(msg, &keypair);
-    secp.verify_schnorr(&sig, msg, &XOnlyPublicKey::from_keypair(&keypair))
+    secp.verify_schnorr(&sig, msg, &XOnlyPublicKey::from_keypair(&keypair).0)
         .expect("invalid or corrupted schnorr signature");
 
     let final_signature = schnorr::SchnorrSig { sig, hash_ty };
@@ -569,7 +576,7 @@ impl SignersContainer {
         self.0
             .values()
             .filter_map(|signer| signer.descriptor_secret_key())
-            .filter_map(|secret| secret.as_public(secp).ok().map(|public| (public, secret)))
+            .filter_map(|secret| secret.to_public(secp).ok().map(|public| (public, secret)))
             .collect()
     }
 
@@ -594,8 +601,13 @@ impl SignersContainer {
             };
 
             match secret {
-                DescriptorSecretKey::SinglePriv(private_key) => container.add_external(
-                    SignerId::from(private_key.key.public_key(secp).to_pubkeyhash()),
+                DescriptorSecretKey::Single(private_key) => container.add_external(
+                    SignerId::from(
+                        private_key
+                            .key
+                            .public_key(secp)
+                            .to_pubkeyhash(SigType::Ecdsa),
+                    ),
                     SignerOrdering::default(),
                     Arc::new(SignerWrapper::new(private_key.key, ctx)),
                 ),
@@ -696,14 +708,14 @@ pub struct SignOptions {
     /// Defaults to `false` which will only allow signing using `SIGHASH_ALL`.
     pub allow_all_sighashes: bool,
 
-    /// Whether to remove partial_sigs from psbt inputs while finalizing psbt.
+    /// Whether to remove partial signatures from the PSBT inputs while finalizing PSBT.
     ///
-    /// Defaults to `true` which will remove partial_sigs after finalizing.
+    /// Defaults to `true` which will remove partial signatures during finalization.
     pub remove_partial_sigs: bool,
 
-    /// Whether to try finalizing psbt input after the inputs are signed.
+    /// Whether to try finalizing the PSBT after the inputs are signed.
     ///
-    /// Defaults to `true` which will try fianlizing psbt after inputs are signed.
+    /// Defaults to `true` which will try finalizing PSBT after inputs are signed.
     pub try_finalize: bool,
 
     /// Specifies which Taproot script-spend leaves we should sign for. This option is
@@ -717,10 +729,15 @@ pub struct SignOptions {
     ///
     /// Defaults to `true`, i.e., we always try to sign with the taproot internal key.
     pub sign_with_tap_internal_key: bool,
+
+    /// Whether we should grind ECDSA signature to ensure signing with low r
+    /// or not.
+    /// Defaults to `true`, i.e., we always grind ECDSA signature to sign with low r.
+    pub allow_grinding: bool,
 }
 
 /// Customize which taproot script-path leaves the signer should sign.
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub enum TapLeavesOptions {
     /// The signer will sign all the leaves it has a key for.
     All,
@@ -750,6 +767,7 @@ impl Default for SignOptions {
             try_finalize: true,
             tap_leaves_options: TapLeavesOptions::default(),
             sign_with_tap_internal_key: true,
+            allow_grinding: true,
         }
     }
 }
@@ -921,11 +939,8 @@ impl ComputeSighash for Tap {
             .unwrap_or_else(|| SchnorrSighashType::Default.into())
             .schnorr_hash_ty()
             .map_err(|_| SignerError::InvalidSighash)?;
-        let witness_utxos = psbt
-            .inputs
-            .iter()
-            .cloned()
-            .map(|i| i.witness_utxo)
+        let witness_utxos = (0..psbt.inputs.len())
+            .map(|i| psbt.get_utxo_for(i))
             .collect::<Vec<_>>();
         let mut all_witness_utxos = vec![];
 

src/wallet/tx_builder.rs

@@ -42,9 +42,7 @@ use std::default::Default;
 use std::marker::PhantomData;
 
 use bitcoin::util::psbt::{self, PartiallySignedTransaction as Psbt};
-use bitcoin::{OutPoint, Script, Transaction};
-
-use miniscript::descriptor::DescriptorTrait;
+use bitcoin::{LockTime, OutPoint, Script, Sequence, Transaction};
 
 use super::coin_selection::{CoinSelectionAlgorithm, DefaultCoinSelectionAlgorithm};
 use crate::{database::BatchDatabase, Error, Utxo, Wallet};
@@ -139,7 +137,7 @@ pub(crate) struct TxParams {
     pub(crate) manually_selected_only: bool,
     pub(crate) sighash: Option<psbt::PsbtSighashType>,
     pub(crate) ordering: TxOrdering,
-    pub(crate) locktime: Option<u32>,
+    pub(crate) locktime: Option<LockTime>,
     pub(crate) rbf: Option<RbfValue>,
     pub(crate) version: Option<Version>,
     pub(crate) change_policy: ChangeSpendPolicy,
@@ -147,7 +145,7 @@ pub(crate) struct TxParams {
     pub(crate) add_global_xpubs: bool,
     pub(crate) include_output_redeem_witness_script: bool,
     pub(crate) bumping_fee: Option<PreviousFee>,
-    pub(crate) current_height: Option<u32>,
+    pub(crate) current_height: Option<LockTime>,
     pub(crate) allow_dust: bool,
 }
 
@@ -426,7 +424,7 @@ impl<'a, D: BatchDatabase, Cs: CoinSelectionAlgorithm<D>, Ctx: TxBuilderContext>
     /// Use a specific nLockTime while creating the transaction
     ///
     /// This can cause conflicts if the wallet's descriptors contain an "after" (OP_CLTV) operator.
-    pub fn nlocktime(&mut self, locktime: u32) -> &mut Self {
+    pub fn nlocktime(&mut self, locktime: LockTime) -> &mut Self {
         self.params.locktime = Some(locktime);
         self
     }
@@ -541,7 +539,7 @@ impl<'a, D: BatchDatabase, Cs: CoinSelectionAlgorithm<D>, Ctx: TxBuilderContext>
     ///
     /// If the `nsequence` is higher than `0xFFFFFFFD` an error will be thrown, since it would not
     /// be a valid nSequence to signal RBF.
-    pub fn enable_rbf_with_sequence(&mut self, nsequence: u32) -> &mut Self {
+    pub fn enable_rbf_with_sequence(&mut self, nsequence: Sequence) -> &mut Self {
         self.params.rbf = Some(RbfValue::Value(nsequence));
         self
     }
@@ -558,7 +556,7 @@ impl<'a, D: BatchDatabase, Cs: CoinSelectionAlgorithm<D>, Ctx: TxBuilderContext>
     ///
     /// In both cases, if you don't provide a current height, we use the last sync height.
     pub fn current_height(&mut self, height: u32) -> &mut Self {
-        self.params.current_height = Some(height);
+        self.params.current_height = Some(LockTime::from_height(height).expect("Invalid height"));
         self
     }
 
@@ -703,7 +701,7 @@ impl TxOrdering {
                 #[cfg(not(test))]
                 let mut rng = rand::thread_rng();
                 #[cfg(test)]
-                let mut rng = rand::rngs::StdRng::seed_from_u64(0);
+                let mut rng = rand::rngs::StdRng::seed_from_u64(12345);
 
                 tx.output.shuffle(&mut rng);
             }
@@ -736,13 +734,13 @@ impl Default for Version {
 #[derive(Debug, Ord, PartialOrd, Eq, PartialEq, Hash, Clone, Copy)]
 pub(crate) enum RbfValue {
     Default,
-    Value(u32),
+    Value(Sequence),
 }
 
 impl RbfValue {
-    pub(crate) fn get_value(&self) -> u32 {
+    pub(crate) fn get_value(&self) -> Sequence {
         match self {
-            RbfValue::Default => 0xFFFFFFFD,
+            RbfValue::Default => Sequence::ENABLE_RBF_NO_LOCKTIME,
             RbfValue::Value(v) => *v,
         }
     }
@@ -858,10 +856,12 @@ mod test {
     }
 
     fn get_test_utxos() -> Vec<LocalUtxo> {
+        use bitcoin::hashes::Hash;
+
         vec![
             LocalUtxo {
                 outpoint: OutPoint {
-                    txid: Default::default(),
+                    txid: bitcoin::Txid::from_inner([0; 32]),
                     vout: 0,
                 },
                 txout: Default::default(),
@@ -870,7 +870,7 @@ mod test {
             },
             LocalUtxo {
                 outpoint: OutPoint {
-                    txid: Default::default(),
+                    txid: bitcoin::Txid::from_inner([0; 32]),
                     vout: 1,
                 },
                 txout: Default::default(),

src/wallet/utils.rs

@@ -9,23 +9,11 @@
 // You may not use this file except in accordance with one or both of these
 // licenses.
 
-use bitcoin::blockdata::script::Script;
 use bitcoin::secp256k1::{All, Secp256k1};
+use bitcoin::{LockTime, Script, Sequence};
 
 use miniscript::{MiniscriptKey, Satisfier, ToPublicKey};
 
-// MSB of the nSequence. If set there's no consensus-constraint, so it must be disabled when
-// spending using CSV in order to enforce CSV rules
-pub(crate) const SEQUENCE_LOCKTIME_DISABLE_FLAG: u32 = 1 << 31;
-// When nSequence is lower than this flag the timelock is interpreted as block-height-based,
-// otherwise it's time-based
-pub(crate) const SEQUENCE_LOCKTIME_TYPE_FLAG: u32 = 1 << 22;
-// Mask for the bits used to express the timelock
-pub(crate) const SEQUENCE_LOCKTIME_MASK: u32 = 0x0000FFFF;
-
-// Threshold for nLockTime to be considered a block-height-based timelock rather than time-based
-pub(crate) const BLOCKS_TIMELOCK_THRESHOLD: u32 = 500000000;
-
 /// Trait to check if a value is below the dust limit.
 /// We are performing dust value calculation for a given script public key using rust-bitcoin to
 /// keep it compatible with network dust rate
@@ -38,7 +26,7 @@ pub trait IsDust {
 
 impl IsDust for u64 {
     fn is_dust(&self, script: &Script) -> bool {
-        *self < script.dust_value().as_sat()
+        *self < script.dust_value().to_sat()
     }
 }
 
@@ -56,19 +44,15 @@ impl After {
     }
 }
 
-pub(crate) fn check_nsequence_rbf(rbf: u32, csv: u32) -> bool {
-    // This flag cannot be set in the nSequence when spending using OP_CSV
-    if rbf & SEQUENCE_LOCKTIME_DISABLE_FLAG != 0 {
+pub(crate) fn check_nsequence_rbf(rbf: Sequence, csv: Sequence) -> bool {
+    // The RBF value must enable relative timelocks
+    if !rbf.is_relative_lock_time() {
         return false;
     }
 
-    let mask = SEQUENCE_LOCKTIME_TYPE_FLAG | SEQUENCE_LOCKTIME_MASK;
-    let rbf = rbf & mask;
-    let csv = csv & mask;
-
     // Both values should be represented in the same unit (either time-based or
     // block-height based)
-    if (rbf < SEQUENCE_LOCKTIME_TYPE_FLAG) != (csv < SEQUENCE_LOCKTIME_TYPE_FLAG) {
+    if rbf.is_time_locked() != csv.is_time_locked() {
         return false;
     }
 
@@ -80,24 +64,10 @@ pub(crate) fn check_nsequence_rbf(rbf: u32, csv: u32) -> bool {
     true
 }
 
-pub(crate) fn check_nlocktime(nlocktime: u32, required: u32) -> bool {
-    // Both values should be expressed in the same unit
-    if (nlocktime < BLOCKS_TIMELOCK_THRESHOLD) != (required < BLOCKS_TIMELOCK_THRESHOLD) {
-        return false;
-    }
-
-    // The value should be at least `required`
-    if nlocktime < required {
-        return false;
-    }
-
-    true
-}
-
 impl<Pk: MiniscriptKey + ToPublicKey> Satisfier<Pk> for After {
-    fn check_after(&self, n: u32) -> bool {
+    fn check_after(&self, n: LockTime) -> bool {
         if let Some(current_height) = self.current_height {
-            current_height >= n
+            current_height >= n.to_consensus_u32()
         } else {
             self.assume_height_reached
         }
@@ -125,10 +95,15 @@ impl Older {
 }
 
 impl<Pk: MiniscriptKey + ToPublicKey> Satisfier<Pk> for Older {
-    fn check_older(&self, n: u32) -> bool {
+    fn check_older(&self, n: Sequence) -> bool {
         if let Some(current_height) = self.current_height {
             // TODO: test >= / >
-            current_height as u64 >= self.create_height.unwrap_or(0) as u64 + n as u64
+            current_height
+                >= self
+                    .create_height
+                    .unwrap_or(0)
+                    .checked_add(n.to_consensus_u32())
+                    .expect("Overflowing addition")
         } else {
             self.assume_height_reached
         }
@@ -139,11 +114,12 @@ pub(crate) type SecpCtx = Secp256k1<All>;
 
 #[cfg(test)]
 mod test {
-    use super::{
-        check_nlocktime, check_nsequence_rbf, IsDust, BLOCKS_TIMELOCK_THRESHOLD,
-        SEQUENCE_LOCKTIME_TYPE_FLAG,
-    };
-    use crate::bitcoin::Address;
+    // When nSequence is lower than this flag the timelock is interpreted as block-height-based,
+    // otherwise it's time-based
+    pub(crate) const SEQUENCE_LOCKTIME_TYPE_FLAG: u32 = 1 << 22;
+
+    use super::{check_nsequence_rbf, IsDust};
+    use crate::bitcoin::{Address, Sequence};
     use std::str::FromStr;
 
     #[test]
@@ -165,66 +141,40 @@ mod test {
 
     #[test]
     fn test_check_nsequence_rbf_msb_set() {
-        let result = check_nsequence_rbf(0x80000000, 5000);
+        let result = check_nsequence_rbf(Sequence(0x80000000), Sequence(5000));
         assert!(!result);
     }
 
     #[test]
     fn test_check_nsequence_rbf_lt_csv() {
-        let result = check_nsequence_rbf(4000, 5000);
+        let result = check_nsequence_rbf(Sequence(4000), Sequence(5000));
         assert!(!result);
     }
 
     #[test]
     fn test_check_nsequence_rbf_different_unit() {
-        let result = check_nsequence_rbf(SEQUENCE_LOCKTIME_TYPE_FLAG + 5000, 5000);
+        let result =
+            check_nsequence_rbf(Sequence(SEQUENCE_LOCKTIME_TYPE_FLAG + 5000), Sequence(5000));
         assert!(!result);
     }
 
     #[test]
     fn test_check_nsequence_rbf_mask() {
-        let result = check_nsequence_rbf(0x3f + 10_000, 5000);
+        let result = check_nsequence_rbf(Sequence(0x3f + 10_000), Sequence(5000));
         assert!(result);
     }
 
     #[test]
     fn test_check_nsequence_rbf_same_unit_blocks() {
-        let result = check_nsequence_rbf(10_000, 5000);
+        let result = check_nsequence_rbf(Sequence(10_000), Sequence(5000));
         assert!(result);
     }
 
     #[test]
     fn test_check_nsequence_rbf_same_unit_time() {
         let result = check_nsequence_rbf(
-            SEQUENCE_LOCKTIME_TYPE_FLAG + 10_000,
-            SEQUENCE_LOCKTIME_TYPE_FLAG + 5000,
-        );
-        assert!(result);
-    }
-
-    #[test]
-    fn test_check_nlocktime_lt_cltv() {
-        let result = check_nlocktime(4000, 5000);
-        assert!(!result);
-    }
-
-    #[test]
-    fn test_check_nlocktime_different_unit() {
-        let result = check_nlocktime(BLOCKS_TIMELOCK_THRESHOLD + 5000, 5000);
-        assert!(!result);
-    }
-
-    #[test]
-    fn test_check_nlocktime_same_unit_blocks() {
-        let result = check_nlocktime(10_000, 5000);
-        assert!(result);
-    }
-
-    #[test]
-    fn test_check_nlocktime_same_unit_time() {
-        let result = check_nlocktime(
-            BLOCKS_TIMELOCK_THRESHOLD + 10_000,
-            BLOCKS_TIMELOCK_THRESHOLD + 5000,
+            Sequence(SEQUENCE_LOCKTIME_TYPE_FLAG + 10_000),
+            Sequence(SEQUENCE_LOCKTIME_TYPE_FLAG + 5000),
         );
         assert!(result);
     }

src/wallet/verify.rs

@@ -29,6 +29,8 @@ use crate::error::Error;
 /// Depending on the [capabilities](crate::blockchain::Blockchain::get_capabilities) of the
 /// [`Blockchain`] backend, the method could fail when called with old "historical" transactions or
 /// with unconfirmed transactions that have been evicted from the backend's memory.
+///
+/// [`Blockchain`]: crate::blockchain::Blockchain
 pub fn verify_tx<D: Database, B: GetTx>(
     tx: &Transaction,
     database: &D,